使用实体框架管理TypeList

Question

I am in a predicament where I have several lists as part of the business logic that will need to be dropdown selections (w/ Id as value and FriendlyName as Description ) on the front-end.

Additionally, I will be doing different things in the business logic based on the saved database selection. This means I will either need GlobalConstants or Enums that match the Ids in my code.

Should I use Enums , Create a table for every single list, or create a general tables called TypeList and TypeListItem when using EF?

Answer 1

This answer does not provide a concrete solution to your problem, but I hope it can give you some hint.

There are several posts in SO about that issue, for instance this one . A popular way to do it is to have enums in your code, and also tables in your database to store the enum extended info (like display names and other data), and to keep them synchronized by applying changes in your enums to the database tables contents using custom code (try to avoid having to manually write SQL scripts).

EF6 does not provide an out-of-the-box solution for this. There are several Nuget packages that implement that synchronization custom code. I can't give you advice about them as I have not used them.

Also you have to consider your specific scenario: how frequently your lists change, the size of your lists, whether you only need some pretty name to display or some other extra data, whether you will allow your users to change the lists or it will only be done by the developers, whether you need these data to be changed dynamically at run time (without modifying/compiling/publishing your code), the version of EF you are using, etc. A future version of EF might provide support for this.

If your case if you only have this FriendlyName extended data and none of the complex scenarios cited above, perhaps you could manage without the database tables. You could for instance use an enum for each list, and an extension where you define an array or dictionary for your enum where you store those extra data. You would have to update those data in your code every time the list of values changes.

An example implementation of this for a simple enum CategoryStatus with two values and and extra LocalizedName item (which allows to use Resources values for translated texts):

public enum CategoryStatus
{
    Active = 0,
    Inactive = 1
}

public static class CategoryStatusExtension
{
    private static string[] localizedNames = new string[] { 
        Resources.Strings.CategoryStatus_Active,
        Resources.Strings.CategoryStatus_Inactive
    };

    public static string LocalizedName(this CategoryStatus self)
    {
        switch (self)
        {
            case CategoryStatus.Active:
                return localizedNames[0];
                break;

            case CategoryStatus.Inactive:
                return localizedNames[1];
                break;
        }
        return null;
        //int index = (int)self - 1;
        //return localizedNames[index];
    }
}

You use it like this:

var categoryStatus = CategoryStatus.Active;
var textToUse = categoryStatus.LocalizedName();

You could also find a way to automate a little more the search of the values instead of using an explicit switch , like in the commented out code.

About using only one table for all enums, it again depends on those kind of considerations. If your lists are small, you don't have many of them, and you will not get a lot of new lists in the future, then you should probably use separate tables for each enum. I think your code will be easier to write/maintain if you use separate tables.