Динамическое перечисление в С#

Ответ 1

Я делаю это точно, но для этого вам нужно сделать какое-то генерирование кода.

В моем решении я добавил проект "EnumeratedTypes" . Это консольное приложение, которое получает все значения из базы данных и создает из них перечисления. Затем он сохраняет все перечисления в сборку.

Код генерации enum выглядит следующим образом:

// Get the current application domain for the current thread
AppDomain currentDomain = AppDomain.CurrentDomain;

// Create a dynamic assembly in the current application domain,
// and allow it to be executed and saved to disk.
AssemblyName name = new AssemblyName("MyEnums");
AssemblyBuilder assemblyBuilder = currentDomain.DefineDynamicAssembly(name,
                                      AssemblyBuilderAccess.RunAndSave);

// Define a dynamic module in "MyEnums" assembly.
// For a single-module assembly, the module has the same name as the assembly.
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(name.Name,
                                  name.Name + ".dll");

// Define a public enumeration with the name "MyEnum" and an underlying type of Integer.
EnumBuilder myEnum = moduleBuilder.DefineEnum("EnumeratedTypes.MyEnum",
                         TypeAttributes.Public, typeof(int));

// Get data from database
MyDataAdapter someAdapter = new MyDataAdapter();
MyDataSet.MyDataTable myData = myDataAdapter.GetMyData();

foreach (MyDataSet.MyDataRow row in myData.Rows)
{
    myEnum.DefineLiteral(row.Name, row.Key);
}

// Create the enum
myEnum.CreateType();

// Finally, save the assembly
assemblyBuilder.Save(name.Name + ".dll");

Мои другие проекты в решении ссылаются на эту сгенерированную сборку. В результате я могу использовать динамические перечисления в коде, в комплекте с intellisense.

Затем я добавил событие post-build, так что после создания этого проекта "EnumeratedTypes" он запускается сам и генерирует файл "MyEnums.dll".

Кстати, это помогает изменить порядок сборки вашего проекта, чтобы сначала создать "EnumeratedTypes" . В противном случае, как только вы начнете использовать вашу динамически генерируемую .dll, вы не сможете выполнить сборку, если DLL когда-нибудь удалится. (Проблема с цыплятами и яйцами - ваши другие проекты в решении нуждаются в этом .dll для правильной сборки, и вы не можете создать .dll, пока не создадите свое решение...)

Я получил большую часть вышеуказанного кода эту статью msdn.

Надеюсь, это поможет!

Ответ 2

Вы понимаете, что Enums необходимо указывать во время компиляции? Вы не можете динамически добавлять перечисления во время выполнения - и почему бы вам не было использования/ссылки на них в коде?

От Professional С# 2008:

Реальная мощность перечислений в С# заключается в том, что за кулисами они создаются как структуры, полученные из базового класса System.Enum. Это означает, что можно вызвать методы против них для выполнения некоторых полезных задач. Обратите внимание, что из-за реализации .NET Framework нет потери производительности, связанной с обработкой синтаксически перечислений в виде структур. На практике, как только ваш код будет скомпилирован, перечисления будут существовать как примитивные типы, точно так же, как int и float.

Итак, я не уверен, что вы можете использовать Enums так, как хотите.

Ответ 3

Нужно ли быть фактическим перечислением? Как насчет использования Dictionary<string,int> вместо этого?

например

Dictionary<string, int> MyEnum = new Dictionary(){{"One", 1}, {"Two", 2}};
Console.WriteLine(MyEnum["One"]);

Ответ 4

Просто показывая ответ Pandincus с кодом "полки" и некоторым объяснением: Вам нужно два решения для этого примера (я знаю, что это можно сделать и с одним из них;), пусть продвинутые студенты представляют его...

Итак, вот DDL SQL для таблицы:

USE [ocms_dev]
    GO

CREATE TABLE [dbo].[Role](
    [RoleId] [int] IDENTITY(1,1) NOT NULL,
    [RoleName] [varchar](50) NULL
) ON [PRIMARY]

Итак, вот консольная программа, создающая dll:

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Reflection.Emit;
using System.Data.Common;
using System.Data;
using System.Data.SqlClient;

namespace DynamicEnums
{
    class EnumCreator
    {
        // after running for first time rename this method to Main1
        static void Main ()
        {
            string strAssemblyName = "MyEnums";
            bool flagFileExists = System.IO.File.Exists (
                   AppDomain.CurrentDomain.SetupInformation.ApplicationBase + 
                   strAssemblyName + ".dll"
            );

            // Get the current application domain for the current thread
            AppDomain currentDomain = AppDomain.CurrentDomain;

            // Create a dynamic assembly in the current application domain,
            // and allow it to be executed and saved to disk.
            AssemblyName name = new AssemblyName ( strAssemblyName );
            AssemblyBuilder assemblyBuilder = 
                    currentDomain.DefineDynamicAssembly ( name,
                            AssemblyBuilderAccess.RunAndSave );

            // Define a dynamic module in "MyEnums" assembly.
            // For a single-module assembly, the module has the same name as
            // the assembly.
            ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule (
                    name.Name, name.Name + ".dll" );

            // Define a public enumeration with the name "MyEnum" and
            // an underlying type of Integer.
            EnumBuilder myEnum = moduleBuilder.DefineEnum (
                    "EnumeratedTypes.MyEnum",
                    TypeAttributes.Public,
                    typeof ( int )
            );

            #region GetTheDataFromTheDatabase
            DataTable tableData = new DataTable ( "enumSourceDataTable" );

            string connectionString = "Integrated Security=SSPI;Persist " +
                    "Security Info=False;Initial Catalog=ocms_dev;Data " +
                    "Source=ysg";

            using (SqlConnection connection = 
                    new SqlConnection ( connectionString ))
            {

                SqlCommand command = connection.CreateCommand ();
                command.CommandText = string.Format ( "SELECT [RoleId], " + 
                        "[RoleName] FROM [ocms_dev].[dbo].[Role]" );

                Console.WriteLine ( "command.CommandText is " + 
                        command.CommandText );

                connection.Open ();
                tableData.Load ( command.ExecuteReader ( 
                        CommandBehavior.CloseConnection
                ) );
            } //eof using

            foreach (DataRow dr in tableData.Rows)
            {
                myEnum.DefineLiteral ( dr[1].ToString (),
                        Convert.ToInt32 ( dr[0].ToString () ) );
            }
            #endregion GetTheDataFromTheDatabase

            // Create the enum
            myEnum.CreateType ();

            // Finally, save the assembly
            assemblyBuilder.Save ( name.Name + ".dll" );
        } //eof Main 
    } //eof Program
} //eof namespace 

Вот консольное программирование печати вывода (помните, что он должен ссылаться на dll). Пусть продвинутые студенты представляют решение для объединения всего в одном решении с динамической загрузкой и проверкой, если уже построена dll.

// add the reference to the newly generated dll
use MyEnums ; 

class Program
{
    static void Main ()
    {
        Array values = Enum.GetValues ( typeof ( EnumeratedTypes.MyEnum ) );

        foreach (EnumeratedTypes.MyEnum val in values)
        {
            Console.WriteLine ( String.Format ( "{0}: {1}",
                    Enum.GetName ( typeof ( EnumeratedTypes.MyEnum ), val ),
                    val ) );
        }

        Console.WriteLine ( "Hit enter to exit " );
        Console.ReadLine ();
    } //eof Main 
} //eof Program

Ответ 5

Скажем, у вас есть следующее в вашей БД:

table enums
-----------------
| id | name     |
-----------------
| 0  | MyEnum   |
| 1  | YourEnum |
-----------------

table enum_values
----------------------------------
| id | enums_id | value | key    |
----------------------------------
| 0  | 0        | 0     | Apple  |
| 1  | 0        | 1     | Banana |
| 2  | 0        | 2     | Pear   |
| 3  | 0        | 3     | Cherry |
| 4  | 1        | 0     | Red    |
| 5  | 1        | 1     | Green  |
| 6  | 1        | 2     | Yellow |
----------------------------------

Создайте выбор, чтобы получить нужные значения:

select * from enums e inner join enum_values ev on ev.enums_id=e.id where e.id=0

Создайте исходный код для перечисления, и вы получите что-то вроде:

String enumSourceCode = "enum " + enumName + "{" + enumKey1 + "=" enumValue1 + "," + enumKey2 + ... + "}";

(очевидно, это построено в некоторой петле).

Затем идет интересная часть, компиляция вашего перечисления и его использование:

CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
CompilerParameters cs = new CompilerParameters();
cp.GenerateInMemory = True;

CompilerResult result = provider.CompileAssemblyFromSource(cp, enumSourceCode);

Type enumType = result.CompiledAssembly.GetType(enumName);

Теперь у вас есть тип, скомпилированный и готовый к использованию.
Чтобы получить значение перечисления, хранящееся в БД, вы можете использовать:

[Enum].Parse(enumType, value);

где значение может быть либо целочисленным значением (0, 1, и т.д.), либо текстом/ключом перечисления (Apple, Banana и т.д.)

Ответ 6

Я сделал это с шаблоном T4. Весьма тривиально отбрасывать файл .tt в ваш проект и настраивать Visual Studio для запуска шаблона T4 в качестве этапа предварительной сборки.

T4 генерирует .cs файл, что означает, что вы можете просто запросить базу данных и построить перечисление в файле .cs из результата. Проводящийся в качестве задачи предварительной сборки, он заново создаст ваше перечисление для каждой сборки, или вы можете вручную запустить T4 вручную.

Ответ 7

Вы хотите System.Web.Compilation.BuildProvider

Я также сомневаюсь в мудрости этого, но тогда, возможно, хороший случай использования, о котором я не могу думать.

Что вы ищете, Поставщики сборки, то есть System.Web.Compilation.BuildProvider

Они эффективно используются очень SubSonic, вы можете скачать источник и посмотреть, как они используйте их, вам не понадобится ничего такого же сложного, как то, что они делают.

Надеюсь, что это поможет.

Ответ 8

Мне всегда нравится писать собственное "пользовательское перечисление". Чем у меня есть один класс, который немного сложнее, но я могу его повторно использовать:

public abstract class CustomEnum
{
    private readonly string _name;
    private readonly object _id;

    protected CustomEnum( string name, object id )
    {
        _name = name;
        _id = id;
    }

    public string Name
    {
        get { return _name; }
    }

    public object Id
    {
        get { return _id; }
    }

    public override string ToString()
    {
        return _name;
    }
}

public abstract class CustomEnum<TEnumType, TIdType> : CustomEnum
    where TEnumType : CustomEnum<TEnumType, TIdType>
{
    protected CustomEnum( string name, TIdType id )
        : base( name, id )
    { }

    public new TIdType Id
    {
        get { return (TIdType)base.Id; }
    }

    public static TEnumType FromName( string name )
    {
        try
        {
            return FromDelegate( entry => entry.Name.Equals( name ) );
        }
        catch (ArgumentException ae)
        {
            throw new ArgumentException( "Illegal name for custom enum '" + typeof( TEnumType ).Name + "'", ae );
        }
    }

    public static TEnumType FromId( TIdType id )
    {
        try
        {
            return FromDelegate( entry => entry.Id.Equals( id ) );
        }
        catch (ArgumentException ae)
        {
            throw new ArgumentException( "Illegal id for custom enum '" + typeof( TEnumType ).Name + "'", ae );
        }
    }

    public static IEnumerable<TEnumType> GetAll()
    {
        var elements = new Collection<TEnumType>();
        var infoArray = typeof( TEnumType ).GetFields( BindingFlags.Public | BindingFlags.Static );

        foreach (var info in infoArray)
        {
            var type = info.GetValue( null ) as TEnumType;
            elements.Add( type );
        }

        return elements;
    }

    protected static TEnumType FromDelegate( Predicate<TEnumType> predicate )
    {
        if(predicate == null)
            throw new ArgumentNullException( "predicate" );

        foreach (var entry in GetAll())
        {
            if (predicate( entry ))
                return entry;
        }

        throw new ArgumentException( "Element not found while using predicate" );
    }
}

Теперь мне просто нужно создать мое перечисление, которое я хочу использовать:

 public sealed class SampleEnum : CustomEnum<SampleEnum, int>
    {
        public static readonly SampleEnum Element1 = new SampleEnum( "Element1", 1, "foo" );
        public static readonly SampleEnum Element2 = new SampleEnum( "Element2", 2, "bar" );

        private SampleEnum( string name, int id, string additionalText )
            : base( name, id )
        {
            AdditionalText = additionalText;
        }

        public string AdditionalText { get; private set; }
    }

Наконец, я могу использовать его, как хочу:

 static void Main( string[] args )
        {
            foreach (var element in SampleEnum.GetAll())
            {
                Console.WriteLine( "{0}: {1}", element, element.AdditionalText );
                Console.WriteLine( "Is 'Element2': {0}", element == SampleEnum.Element2 );
                Console.WriteLine();
            }

            Console.ReadKey();
        }

И мой вывод будет:

Element1: foo
Is 'Element2': False

Element2: bar
Is 'Element2': True    

Ответ 9

Вы можете использовать CodeSmith для создания чего-то вроде этого:

http://www.csharping.com/PermaLink,guid,cef1b637-7d37-4691-8e49-138cbf1d51e9.aspx

Ответ 10

Я не думаю, что есть хороший способ сделать то, что вы хотите. И если вы думаете об этом, я не думаю, что это то, что вы действительно хотите.

Если у вас будет динамическое перечисление, это также означает, что вы должны его снабжать динамическим значением, когда вы ссылаетесь на него. Возможно, с большим количеством магии вы могли бы достичь своего рода IntelliSense, который позаботился об этом и сформировал бы перечисление для вас в DLL файл. Но рассмотрите объем выполняемой работы, как неэффективным будет доступ к базе данных для извлечения информации IntelliSense, а также кошмар версии, управляющей сгенерированным DLL файлом.

Если вы действительно не хотите вручную добавлять значения перечисления (вам все равно придется добавлять их в базу данных), вместо этого используйте инструмент генерации кода, например T4. Щелкните правой кнопкой мыши + запустите, и вы получили статическое перечисление, указанное в коде, и вы получите все преимущества использования перечислений.

Ответ 11

Использование динамических перечислений является плохим независимо от того, в каком направлении. Вам придется столкнуться с проблемой "дублирования" данных, чтобы обеспечить легкий и удобный код в будущем.

Если вы начинаете вводить автоматически сгенерированные библиотеки, вы наверняка вызываете больше путаницы с будущими разработчиками, которые должны обновить ваш код, чем просто сделать ваш enum закодированным в соответствующем объекте класса.

Другие примеры дают хороший и захватывающий звук, но думают о накладных расходах на обслуживание кода по сравнению с тем, что вы получаете от него. Кроме того, часто ли эти значения меняются?

Ответ 12

Один из способов сохранить список и создать динамический список значений в одно и то же время - использовать перечисления, которые у вас есть в настоящее время с динамически созданным словарем.

Так как большинство Enums используются в контексте, который они определены для использования, а "динамические перечисления" будут поддерживаться динамическими процессами, вы можете выделить 2.

Первым шагом является создание таблицы/коллекции, в которой хранятся идентификаторы и ссылки для динамических записей. В таблице вы будете автоматически увеличивать максимальную величину Enum.

Теперь идет часть динамических Enums, я предполагаю, что вы будете использовать Enums для создания набора условий, которые применяют набор правил, некоторые из них динамически генерируются.

Get integer from database
If Integer is in Enum -> create Enum -> then run Enum parts
If Integer is not a Enum -> create Dictionary from Table -> then run Dictionary parts.