Enum with a lot of items and a long case statement to convert from string

Question

Recently I wrote this class and it has a enum of all the interaction types a game item can have. What I want to know is, it seems a bit of a stretch to have a huge enum then that long switch, is there any way I can shorten it or improve it without changing it completely?

namespace Sirius.Base.Game.Other.Items
{
    public enum InteractionType
    {
        None,
        Gate,
        Postit,
        Moodlight,
        Trophy,
        Bed,
        Scoreboard,
        VendingMachine,
        Alert,
        OneWayGate,
        LoveShuffler,
        HabboWheel,
        Dice,
        Bottle,
        Hopper,
        Teleport,
        Pool,
        Roller,
        FootballGate,
        Pet0,
        Pet1,
        Pet2,
        Pet3,
        Pet4,
        Pet5,
        Pet6,
        Pet7,
        Pet8,
        Pet9,
        Pet10,
        Pet11,
        Pet12,
        Pet13,
        Pet14,
        Pet15,
        Pet16,
        Pet17,
        Pet18,
        Pet19,
        Pet20,
        Pet21,
        Pet22,
        Pet28,
        Pet29,
        Pet30,
        IceSkates,
        NormalSkates,
        Lowpool,
        Haloweenpool,
        Football,
        FootballGoalGreen,
        FootballGoalYellow,
        FootballGoalBlue,
        FootballGoalRed,
        Footballcountergreen,
        Footballcounteryellow,
        Footballcounterblue,
        Footballcounterred,
        Banzaigateblue,
        Banzaigatered,
        Banzaigateyellow,
        Banzaigategreen,
        Banzaifloor,
        Banzaiscoreblue,
        Banzaiscorered,
        Banzaiscoreyellow,
        Banzaiscoregreen,
        Banzaicounter,
        Banzaitele,
        Banzaipuck,
        Banzaipyramid,
        Freezetimer,
        Freezeexit,
        Freezeredcounter,
        Freezebluecounter,
        Freezeyellowcounter,
        Freezegreencounter,
        FreezeYellowGate,
        FreezeRedGate,
        FreezeGreenGate,
        FreezeBlueGate,
        FreezeTileBlock,
        FreezeTile,
        Jukebox,
        MusicDisc,
        PuzzleBox,
        Toner,
        PressurePad,
        WfFloorSwitch1,
        WfFloorSwitch2,
        Gift,
        Background,
        Mannequin,
        GateVip,
        GuildItem,
        GuildGate,
        GuildForum,
        Tent,
        TentSmall,
        BadgeDisplay,
        Stacktool,
        Television,
        WiredEffect,
        WiredTrigger,
        WiredCondition,
        Wallpaper,
        Floor,
        Landscape,
        Badge,
        CrackableEgg,
        Effect,
        Deal,
        HorseSaddle1,
        HorseSaddle2,
        HorseHairstyle,
        HorseBodyDye,
        HorseHairDye,
        GnomeBox,
        Bot,
        PurchasableClothing,
        PetBreedingBox,
        Arrow,
        Lovelock,
        MonsterplantSeed,
        Cannon,
        Counter,
        CameraPicture,
        FxProvider
    }


    internal static class InteractionTypes
    {
        internal static InteractionType GetTypeFromString(string pType)
        {
            switch (pType.ToLower())
            {
                case "":
                case "default":
                    return InteractionType.None;
                case "gate":
                    return InteractionType.Gate;
                case "postit":
                    return InteractionType.Postit;
                case "dimmer":
                    return InteractionType.Moodlight;
                case "trophy":
                    return InteractionType.Trophy;
                case "bed":
                    return InteractionType.Bed;
                case "scoreboard":
                    return InteractionType.Scoreboard;
                case "vendingmachine":
                    return InteractionType.VendingMachine;
                case "alert":
                    return InteractionType.Alert;
                case "onewaygate":
                    return InteractionType.OneWayGate;
                case "loveshuffler":
                    return InteractionType.LoveShuffler;
                case "habbowheel":
                    return InteractionType.HabboWheel;
                case "dice":
                    return InteractionType.Dice;
                case "hopper":
                    return InteractionType.Hopper;
                case "bottle":
                    return InteractionType.Bottle;
                case "teleport":
                    return InteractionType.Teleport;
                case "pool":
                    return InteractionType.Pool;
                case "roller":
                    return InteractionType.Roller;
                case "fbgate":
                    return InteractionType.FootballGate;
                case "pet0":
                    return InteractionType.Pet0;
                case "pet1":
                    return InteractionType.Pet1;
                case "pet2":
                    return InteractionType.Pet2;
                case "pet3":
                    return InteractionType.Pet3;
                case "pet4":
                    return InteractionType.Pet4;
                case "pet5":
                    return InteractionType.Pet5;
                case "pet6":
                    return InteractionType.Pet6;
                case "pet7":
                    return InteractionType.Pet7;
                case "pet8":
                    return InteractionType.Pet8;
                case "pet9":
                    return InteractionType.Pet9;
                case "pet10":
                    return InteractionType.Pet10;
                case "pet11":
                    return InteractionType.Pet11;
                case "pet12":
                    return InteractionType.Pet12;
                case "pet13":
                    return InteractionType.Pet13;
                case "pet14":
                    return InteractionType.Pet14;
                case "pet15":
                    return InteractionType.Pet15;
                case "pet16":
                    return InteractionType.Pet16;
                case "pet17":
                    return InteractionType.Pet17;
                case "pet18":
                    return InteractionType.Pet18;
                case "pet19":
                    return InteractionType.Pet19;
                case "pet20":
                    return InteractionType.Pet20;
                case "pet21":
                    return InteractionType.Pet21;
                case "pet22":
                    return InteractionType.Pet22;
                case "pet28":
                    return InteractionType.Pet28;
                case "pet29":
                    return InteractionType.Pet29;
                case "pet30":
                    return InteractionType.Pet30;
                case "iceskates":
                    return InteractionType.IceSkates;
                case "rollerskate":
                    return InteractionType.NormalSkates;
                case "lowpool":
                    return InteractionType.Lowpool;
                case "haloweenpool":
                    return InteractionType.Haloweenpool;
                case "ball":
                    return InteractionType.Football;
                case "green_goal":
                    return InteractionType.FootballGoalGreen;
                case "yellow_goal":
                    return InteractionType.FootballGoalYellow;
                case "red_goal":
                    return InteractionType.FootballGoalRed;
                case "blue_goal":
                    return InteractionType.FootballGoalBlue;
                case "green_score":
                    return InteractionType.Footballcountergreen;
                case "yellow_score":
                    return InteractionType.Footballcounteryellow;
                case "blue_score":
                    return InteractionType.Footballcounterblue;
                case "red_score":
                    return InteractionType.Footballcounterred;
                case "bb_blue_gate":
                    return InteractionType.Banzaigateblue;
                case "bb_red_gate":
                    return InteractionType.Banzaigatered;
                case "bb_yellow_gate":
                    return InteractionType.Banzaigateyellow;
                case "bb_green_gate":
                    return InteractionType.Banzaigategreen;
                case "bb_patch":
                    return InteractionType.Banzaifloor;
                case "bb_blue_score":
                    return InteractionType.Banzaiscoreblue;
                case "bb_red_score":
                    return InteractionType.Banzaiscorered;
                case "bb_yellow_score":
                    return InteractionType.Banzaiscoreyellow;
                case "bb_green_score":
                    return InteractionType.Banzaiscoregreen;
                case "banzaicounter":
                    return InteractionType.Banzaicounter;
                case "bb_teleport":
                    return InteractionType.Banzaitele;
                case "banzaipuck":
                    return InteractionType.Banzaipuck;
                case "bb_pyramid":
                    return InteractionType.Banzaipyramid;
                case "freezetimer":
                    return InteractionType.Freezetimer;
                case "freezeexit":
                    return InteractionType.Freezeexit;
                case "freezeredcounter":
                    return InteractionType.Freezeredcounter;
                case "freezebluecounter":
                    return InteractionType.Freezebluecounter;
                case "freezeyellowcounter":
                    return InteractionType.Freezeyellowcounter;
                case "freezegreencounter":
                    return InteractionType.Freezegreencounter;
                case "freezeyellowgate":
                    return InteractionType.FreezeYellowGate;
                case "freezeredgate":
                    return InteractionType.FreezeRedGate;
                case "freezegreengate":
                    return InteractionType.FreezeGreenGate;
                case "freezebluegate":
                    return InteractionType.FreezeBlueGate;
                case "freezetileblock":
                    return InteractionType.FreezeTileBlock;
                case "freezetile":
                    return InteractionType.FreezeTile;
                case "jukebox":
                    return InteractionType.Jukebox;
                case "musicdisc":
                    return InteractionType.MusicDisc;
                case "pressure_pad":
                    return InteractionType.PressurePad;
                case "wf_floor_switch1":
                    return InteractionType.WfFloorSwitch1;
                case "wf_floor_switch2":
                    return InteractionType.WfFloorSwitch2;
                case "puzzlebox":
                    return InteractionType.PuzzleBox;
                case "water":
                    return InteractionType.Pool;
                case "gift":
                    return InteractionType.Gift;
                case "background":
                    return InteractionType.Background;
                case "mannequin":
                    return InteractionType.Mannequin;
                case "vip_gate":
                    return InteractionType.GateVip;
                case "roombg":
                    return InteractionType.Toner;
                case "gld_item":
                    return InteractionType.GuildItem;
                case "gld_gate":
                    return InteractionType.GuildGate;
                case "guild_forum":
                    return InteractionType.GuildForum;
                case "tent":
                    return InteractionType.Tent;
                case "tent_small":
                    return InteractionType.TentSmall;
                case "badge_display":
                    return InteractionType.BadgeDisplay;
                case "stacktool":
                    return InteractionType.Stacktool;
                case "television":
                    return InteractionType.Television;
                case "wired_effect":
                    return InteractionType.WiredEffect;
                case "wired_trigger":
                    return InteractionType.WiredTrigger;
                case "wired_condition":
                    return InteractionType.WiredCondition;
                case "floor":
                    return InteractionType.Floor;
                case "wallpaper":
                    return InteractionType.Wallpaper;
                case "landscape":
                    return InteractionType.Landscape;
                case "badge":
                    return InteractionType.Badge;
                case "crackable_egg":
                    return InteractionType.CrackableEgg;
                case "effect":
                    return InteractionType.Effect;
                case "deal":
                    return InteractionType.Deal;
                case "horse_saddle_1":
                    return InteractionType.HorseSaddle1;
                case "horse_saddle_2":
                    return InteractionType.HorseSaddle2;
                case "horse_hairstyle":
                    return InteractionType.HorseHairstyle;
                case "horse_body_dye":
                    return InteractionType.HorseBodyDye;
                case "horse_hair_dye":
                    return InteractionType.HorseHairDye;
                case "gnome_box":
                    return InteractionType.GnomeBox;
                case "bot":
                    return InteractionType.Bot;
                case "purchasable_clothing":
                    return InteractionType.PurchasableClothing;
                case "pet_breeding_box":
                    return InteractionType.PetBreedingBox;
                case "arrow":
                    return InteractionType.Arrow;
                case "lovelock":
                    return InteractionType.Lovelock;
                case "cannon":
                    return InteractionType.Cannon;
                case "counter":
                    return InteractionType.Counter;
                case "camera_picture":
                    return InteractionType.CameraPicture;
                case "fx_provider":
                    return InteractionType.FxProvider;
                default:
                    return InteractionType.None;
            }
        }
    }
}

Answer 1

Update

Added constructor parameter for the dictionary to avoid lower/capital letter case problems as pointed in the comments.

There are 2 solutions:

First option would be to map string -> InteractionType like this:

private static readonly Dictionary<string, InteractionType> InteractionTypesDictionary = new Dictionary
    <string, InteractionType>(StringComparer.CurrentCultureIgnoreCase)
    {
        [string.Empty] = InteractionType.None,
        ["default"] = InteractionType.None,
        ["gate"] = InteractionType.Gate,
        ["postit"] = InteractionType.Postit,
        //...
    };

Once you have all of your strings there your method will be just 1 line:

internal static InteractionType GetTypeFromString(string pType)
{
    string key = pType.ToLower();
    if(InteractionTypesDictionary.ContainsKey(key))
    {
        return InteractionTypesDictionary[key];
    }
    return InteractionType.None; // you might want to throw exception here.
}

The second option is the one I would prefer, I don't see any reason to not have the same string name as the enum, it's easier to know what exact value you are looking for and you can use some of the predefined functions in the Enum class. This will make your code just a few lines long:

internal static InteractionType GetTypeFromString(string pType)
{
    string[] enumNames = Enum.GetNames(typeof(InteractionType));
    string enumValueName = enumNames.FirstOrDefault(x => pType.IndexOf(x, StringComparison.OrdinalIgnoreCase) >= 0);
    if (enumValueName != null)
    {
        return (InteractionType) Enum.Parse(typeof(InteractionType), enumValueName);
    }
    return InteractionType.None;
}

This is the best solution because the previous 2 violate in some way the Open-Closed principle, because if you add some new value into the enum, you will need to modify some code somewhere in your project, but like this it will work even if you add new values, without updating this specific method. Also this is the shortest version, it simply requires you to have proper strings as parameters e.g

bb_blue_gate

InteractionType.Banzaigateblue

This is wrong and wont work it should be:

banzaigateblue // lower or capital letters dont matter

InteractionType.Banzaigateblue

Answer 2

Load a Dictionary with the descriptions for lookup via code

The benefit is you have the data in one spot

public enum RORW { [Description("Read Only")] RO, [Description("Read Write")] RW };

Need using System.ComponentModel;

Load Dictionary

var type = typeof(RORW);
Dictionary<string, RORW> EnumLookup = new Dictionary<string, RORW>(StringComparer.CurrentCultureIgnoreCase);
foreach (RORW rorw in Enum.GetValues(typeof(RORW)))
{
    Debug.WriteLine(rorw.ToString());
    var memInfo = type.GetMember(rorw.ToString());
    var attributes = memInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
    var description = ((DescriptionAttribute)attributes[0]).Description;
    Debug.WriteLine(description);
    EnumLookup.Add(description, rorw);
}

Answer 3

This isn't the most performant method, but it does simplify and localize the code.

First I would build a custom attribute to hold the string value.

class InputKeyAttribute : Attribute
{
    public string Value { get; private set; }
    public InputKeyAttribute (string value)
    {
        Value = value;
    }
}

And create the extension methods to retrieve the information needed

// This will retrieve the input key
public static string GetInputKey(this Enum value)
{
    Type type = value.GetType();
    string name = Enum.GetName(type, value);
    if (name != null)
    {
        FieldInfo field = type.GetField(name);
        if (field != null)
        {
            InputKeyAttribute attr = 
                   Attribute.GetCustomAttribute(field, 
                     typeof(InputKeyAttribute )) as InputKeyAttribute ;
            if (attr != null)
            {
                return attr.Value;
            }
        }
    }
    return null;
}

// get the enum for the string value. returns 0(None) if not match found
public InteractionType GetInteractionType(this string key)
{
    return Enum.GetValues(typeof(InteractionType )).Cast<InteractionType>()
            .FirstOrDefault(v => String.Equals(v.GetInputKey(), key,
               StringComparison.OrdinalIgnoreCase));
}

Now you can add the attribute to the enum

public enum InteractionType
{
    [InputKey = "Default"]
    None,
    [InputKey = "Gate"]
    Gate,
    [InputKey = "Postit"]
    Postit
    //etc...
}

And then retrieve the value when needed

var InteractionType = ptype.GetInteractiontype();

To solve the performance issue you could implement this to create the lookup dictionary and call from it instead of iterating through all of the enum values on each call. After the initialization of the dictionary, the retrieval call should perform in O(1) time.

private Dictionary<string, InteractionType> interactionTypes;

public InteractionType GetInteractionType(this string key)
{
    if(interactionTypes == null)
    {
        interactionTypes = CreateInteractionDictionary();
    }

    if(interactionTypes.ContainsKey(key))
    {
        return interactionTypes[key];
    }
    else
    {
    return InteractionType.None;
    }
}

private Dictionary<string, InteractionType> CreateInputDictionary()
{
    Dictionary<string, InteractionType> output = new Dictionary<string, InteractionType>(StringComparer.OrdinalIgnoreCase);
    foreach(var value in Enum.GetValues(typeof(InteractionType )).Cast<InteractionType>())
    {
        output.Add(value.GetInputKey(), value);
    }
    return output;
}

Answer 4

Design Review

I challenge the need for a huge enum like this.

Even if you find a succint and maintainable way to map this huge enum from a string, what does this provide you in your code? Do you now have a method that needs a huge switch case on the enum to decide proper actions when the interaction is triggered?

void InteractWith(InteractionType interaction)
{
   switch (interaction)
   {
       case InteractionType.Gate:
           InteractWithAGate();
           break;
       case InteractionType.Moodlight:
           InteractWithAMoodlight();
           break;
       // .. and here we go again
   }
}

Let's consider the SOLID principles. We are in particular interested in Interface segregation principle and just common sense when dealing with OO-design.

Many client-specific interfaces are better than one general-purpose interface.

I would make many different enums, each containing a subset of interactions. I'm also not convinced of the name interaction. Many enum values appear to be assets or items.

enum GateKind
{
    Gate,
    OneWayGate,
    // .. others
}

And have specific methods or even classes that handle these specific interaction types. Some trivial example of a game where a player interacts with items, such as a gate.

class GateState
{
    void HandlePlayerInteraction(Player player, GateKind gate)
    {
       if (player.WantsToEnter(gate))
       {
           player.Enter(gate);
       }
       else
       {
           player.GoBack();
       }
    }
}

Answer 5

Alternative: Use static fields

An alternative solution would eliminate both the enum and the switch, by using static fields instead.

This solution has the advantage of not having to do any bridging/mapping of the string to an enum, while making your code look neat and tidy.

public static class InteractionType
{
    public static readonly string None = "";
    public static readonly string Gate = "gate";
    public static readonly string Postit = "postit";
    public static readonly string Moodlight = "dimmer";
    public static readonly string Trophy = "trophy";
    ...
}

However, among other disadvantages, the one that stands out against your provided code is going to be the default cases, as it would require you deal with assigning the default/unmapped cases manually to None. (i.e. "default" has to be turned into "")

You could fix that by using reflection and enumerate the static fields, to create a List<string> to aid your "cleaning up" of the string, so that it will match up with the static string (our enum/switch replacement).

private static readonly List<string> _interactionTypes = typeof(InteractionType)
    .GetFields(BindingFlags.Static | BindingFlags.Public)
    .Select(_ => _.GetValue(null).ToString())
    .ToList();

public string MatchValidOrDefault(string value)
{
    if (value == null) throw new ArgumentNullException(nameof(value));

    if(_interactionTypes.Contains(value) return value; //exact matches only
    // you can also do alternative matching, such as
    // if(_interactionTypes.Contains(value), StringComparer.CurrentCultureIgnoreCase) return value.ToLower();
    return InteractionType.None;
}

Additional things to consider

Note that this also means that a single static field can be mapped to the same string, for example:

public static readonly string Foo = "foo";
public static readonly string Bar = "foo";

Where the following statement is true...

InteractionType.Foo == InteractionType.Bar // "foo" == "foo"

This solution allows multiple "enums" (static fields) to be mapped to a single string. Which can be useful depending on the requirements of your program.