Can you add to an enum type in run-time

Question

If I have the enum type:

Public enum Sport
{
    Tennis = 0;
    Football = 1;
    Squash = 2;
    Volleyball = 3;
}

Can I somehow add during run-time:

PingPong = 4

Answer 1

If the enum can be defined at program startup, you place the enum in a separate assembly and use a bootstrapper that will recompile the enum, overwriting the old version, and then launch the actual application. It's not the cleanest method, but it works.

Answer 2

Well yes you can create and or alter an Enum at runtime by using the EnumBuilder class, See the sample in MSDN

ModuleBuilder mb = ab.DefineDynamicModule(aName.Name, aName.Name + ".dll");
EnumBuilder eb = mb.DefineEnum("Elevation", TypeAttributes.Public, typeof(int));
eb.DefineLiteral("Low", 0);
eb.DefineLiteral("High", 1);
Type finished = eb.CreateType();

Having an enum value is, in my opinion, preferable over dictionaries or list based solution as one uses less memory and no thread side effects.

Here are some samples on how to load the generated enum when you restart your application. I suggest you pick the one that works for you, you could use the methods provided by the System.AddIn namespace as I guess.. or use your IoC.

I use this when I need to generate data for Machine learning as having an Enum value and is preferable over lookup tables (in memory of database) as I just do not have the IO available with these large data sets.

Happy coding

Walter

Answer 3

I would create a complete Enum, with all the values you will ever need like this

Public enum Sport
{
    Tennis = 0;
    Football = 1;
    Squash = 2;
    Volleyball = 3;
    PingPong = 4;
    Rugby = 5;  // for example
}

And then keep a LIST of Invalid Sport entries, so the list would initially contain PingPong and Rugby. Every time you access the Enum, also check with your Invalid Sports list.

Then you can simply adjust your Invalid Sports List to suit, at any stage

Answer 4

No, you cannot modify types at runtime. You could emit new types, but modifying existing ones is not possible.

Answer 5

The enum has a backing store, defaulting to int if you don't specify it. It is possible to directly assign values outside of the defined values:

Sport pingPong = (Sport)4;

Then you can check for it:

if (value == (Sport)4) {}

That is why you have the static function Enum.IsDefined() for checking if the actual value falls inside the expected values. Note that the function doesn't work for compound flag values.

bool isValueDefined = Enum.IsDefined(typeof(Sport), value);

EDIT: After Hans Passant's comment: You don't have to use the literal value 4. You could use anything which returns an int. For example:

Dictionary<int, string> AdditionalSports = new Dictionary<int, string>();
AdditionalSports.Add(4, "PingPong");

// Usages: if
if (AdditionalSports.ContainsKey(value))
{
    // Maybe do something with AdditionalSports[value], i.e. "PingPong"
}

// In a switch:
switch (value)
{
case default:
    // Since it won't be found in the enum-defined values
    if (AdditionalSports.ContainsKey(value))
    {
        // Maybe do something with AdditionalSports[value], i.e. "PingPong"
    }
}

Answer 6

Here is more Object orientated way to maybe achieve what you are trying to achieve. This solution is inspired by early Java approach to enumeration:

struct Sport {
    readonly int value;
    public Sport(int value) {
        this.value = value;
    }
    public static implicit operator int(Sport sport) {
        return sport.value;
    }
    public static implicit operator Sport(int sport) {
        return new Sport(sport);
    }

    public const int Tennis =       0;
    public const int Football =     1;
    public const int Squash =       2;
    public const int Volleyball =   3;
}

//Usage:
Sport sport = Sport.Volleyball;
switch(sport) {
    case Sport.Squash:
        Console.WriteLine("I bounce really high");
        break;
}
Sport rugby = 5;
if (sport == rugby)
    Console.WriteLine("I am really big and eat a lot");

To walk through different featues of this solution.

1. It's an immutable struct that wraps up an integer value. The value is enforced immutable by readonly keyword.

2. The only way to create one of these structs is to call the constructor that takes the value as a parameter.

3. implicit operator int is there so that the structure can be used in the switch bock - i.e. to make the structure convertible to int.

4. implicit operator Sport is there so that you can assign integer values to the structure i.e. Sport rugby = 5.

5. const values are the sports known at compile time. They can also be used as case labels.

What I would actually do

public static class Sports {
    public static readonly Sport Football = new Sport("Football");
    public static readonly Sport Tennis = new Sport("Tennis");
}

public class Sport {
    public Sport(string name) {
        Name = name;
    }
    public string Name { get; private set; }

    // override object.Equals
    public override bool Equals(object obj) {
        var other = obj as Sport;
        if(other == null) {
            return false;
        }

        return other == this;
    }

    // override object.GetHashCode
    public override int GetHashCode() {
        return Name.GetHashCode();
    }

    public static bool operator == (Sport sport1, Sport sport2) {
        if(Object.ReferenceEquals(sport1, null) && Object.ReferenceEquals(sport2 , null))
            return true;

        if(Object.ReferenceEquals(sport1, null) || Object.ReferenceEquals(sport2, null))
            return false;

        return sport1.Name == sport2.Name;
    }
    public static bool operator !=(Sport sport1, Sport sport2) {
        return !(sport1 == sport2);
    }
}

This would create a value class Sport that has a name. Depending on your application you can extend this class to provide other attributes and methods. Having this as class gives you more flexibility as you can subclass it.

Sports class provides a static collection of sports that are known at compile time. This is similar to how some .NET frameworks handle named colors (i.e. WPF). Here is the usage:

List<Sport> sports = new List<Sport>();

sports.Add(Sports.Football);
sports.Add(Sports.Tennis);
//What if the name contains spaces?
sports.Add(new Sport("Water Polo"));

var otherSport = new Sport("Other sport");

if(sports.Contains(otherSport)) {
    //Do something
}

foreach(var sport in sports) {
    if(sport == otherSport) {
        //Do Something
    } else if(sport == Sports.Football) {
        //do something else
    }
}

Once you do this, you'd find there is actuall very little need for having an enumeration as any conditional operations on the sport type can be handled within the Sport class.

EDIT Realised that my equality operator will throw a StackOverflowException I always keep forgetting to write Object.ReferenceEquals(obj,null) instead of obj==null, which will recurse infinitely.