Including the default case doesn't change the way your code works, but it does make your code more maintainable. By making the code break in an obvious way (log a message and throw an exception), you're including a big red arrow for the intern that your company hires next summer to add a couple features. The arrow says: "Hey, you! Yes, I'm talking to YOU! If you're going to add another value to the enum, you'd better add a case here too." That extra effort might add a few bytes to the compiled program, which is something to consider. But it'll also save someone (maybe even the future you) somewhere between an hour and a day of unproductive head-scratching.
Update: The situation described above, i.e. protecting against values added to an enumeration at some later time, can also be caught by the compiler. Clang (and gcc, I think) will by default issue a warning if you switch on an enumerated type but don't have a case that covers every possible value in the enumeration. So, for example, if you remove the default
case from your switch and add a new value MyBaz
to the enumeration, you'll get a warning that says:
Enumeration value 'MyBaz' not handled in switch
Letting the compiler detect uncovered cases is that it largely eliminates the need for that unreachable default
case that inspired your question in the first place.
I agree with others that this seems overengineered. Usually, you want either a simple enum or a complex hierarchy of classes, it's not a good idea to combine the two.
But if you really want to do this (in C#), I think it's useful to recap what exactly do you want:
- Separate types for the hierarchy
Kingdom
, Phylum
, etc., which do not form inheritance hierarchy (otherwise, Phylum
could be assigned to Kingdom
). Though they could inherit from a common base class.
- Each expression like
Animalia.Chordata.Aves
has to be assignable to a variable, which means we have to work with instances, not nested static types. This is especially problematic for the root type, because there are no global variables in C#. You could solve that by using a singleton. Also, I think there should be only one root, so the code above would become something like Organisms.Instance.Animalia.Chordata.Aves
.
- Each member has to be a different type, so that
Animalia.Chordata
compiled, but Plantae.Chordata
didn't.
- Each member needs to somehow know all its children, for the
IsMember()
method to work.
The way I would implement these requirements is to start with a class like EnumSet<TChild>
(though the name could be better), where TChild
is the type of the children of this level in hierarchy. This class would also contain a collection of all its children (see later about filling it). We also need another type to represent leaf level of the hierarchy: non-generic EnumSet
:
abstract class EnumSet
{}
abstract class EnumSet<TChild> : EnumSet where TChild : EnumSet
{
protected IEnumerable<TChild> Children { get; private set; }
public bool Contains(TChild child)
{
return Children.Contains(child);
}
}
Now we need to create a class for each level in the hierarchy:
abstract class Root : EnumSet<Kingdom>
{}
abstract class Kingdom : EnumSet<Phylum>
{}
abstract class Phylum : EnumSet
{}
And finally some concrete classes:
class Organisms : Root
{
public static readonly Organisms Instance = new Organisms();
private Organisms()
{}
public readonly Animalia Animalia = new Animalia();
public readonly Plantae Plantae = new Plantae();
}
class Plantae : Kingdom
{
public readonly Anthophyta Anthophyta = new Anthophyta();
}
class Anthophyta : Phylum
{}
class Animalia : Kingdom
{
public readonly Chordata Chordata = new Chordata();
}
class Chordata : Phylum
{}
Notice that children are always fields of the parent class. What this means is that to fill the Children
collection, we can use reflection:
public EnumSet()
{
Children = GetType().GetFields(BindingFlags.Instance | BindingFlags.Public)
.Select(f => f.GetValue(this))
.Cast<TChild>()
.ToArray();
}
One problem with this approach is that Contains()
always works only one level down. So, you can do Organisms.Instance.Contains(animalia)
, but not .Contains(chordata)
. You can do that by adding overloads of Contains()
to the specific hierarchy classes, e.g.:
abstract class Root : EnumSet<Kingdom>
{
public bool Contains(Phylum phylum)
{
return Children.Any(c => c.Contains(phylum));
}
}
But this would be a lot of work for deep hierarchies.
After all of this, you end up with quite a lot of repetitive code. One way to fix that would be to have a text file that describes the hierarchy and use a T4 template to generate all the classes based on that.
Best Answer
Depending on your language, you should just be able to pass in a garbage value to the Error constructor. Most languages just use integers for enum values. In pseudo-code: