Veritabanı arama tablosundaki değerlere dayalı olarak otomatik olarak Enum oluşturulsun mu?

Nasıl otomatik olarak bir enum oluşturabilirim ve daha sonra C # 'daki değerlerini veritabanı arama tablosundaki değerlere göre (kurumsal kitaplık veri katmanını kullanarak) nasıl kullanabilirim?

Örneğin, veritabanına yeni bir arama değeri eklersem, ek statik numaralandırma değeri bildirimini kodda manuel olarak eklemek zorunda kalmak istemiyorum - numaralandırmayı veritabanı ile senkronize tutmak istiyorum.

Böyle bir şey var mı?

Kod tarafından oluşturulan statik bir numaralandırma oluşturmak istemiyorum ( Kod Projesi Makalesine göre Kod Oluşturucu - Veritabanı arama tablolarından otomatik olarak enum kodu oluşturma ) ve tamamen otomatik olmasını tercih ederim.

Ben de aynısını yapıyorum ama ihtiyacın var çalışmalarına bunun için kod oluşturma çeşit yapmak.

Çözümüme bir "EnumeratedTypes" projesi ekledim. Bu, tüm değerleri veritabanından alan ve bunlardan numaralandırmaları oluşturan bir konsol uygulamasıdır. Daha sonra tüm numaralandırmaları bir derlemeye kaydeder.

Numaralandırma oluşturma kodu şu şekildedir:

// 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");

Çözümdeki diğer projelerim bu oluşturulan montajı referans alıyor. Sonuç olarak, dinamik numaralandırmaları kodda intellisense ile tamamlayabilirim.

Ardından, bu "EnumeratedTypes" projesi oluşturulduktan sonra kendi kendini çalıştırması ve "MyEnums.dll" dosyasını oluşturması için bir post-build olayı ekledim.

Bu arada, yapım sırasını değiştirmeye yardımcı olur "EnumeratedTypes" inşa edilecek şekilde projenizin . Aksi takdirde, dinamik olarak oluşturulmuş .dll'nizi kullanmaya başladığınızda, .dll silinirse bir derleme yapamazsınız. (Tavuk ve yumurta türü bir sorun - çözümdeki diğer projelerinizin düzgün bir şekilde oluşturulması için bu .dll'ye ihtiyacı var ve çözümünüzü oluşturana kadar .dll'yi oluşturamazsınız ...)

Yukarıdaki kodun çoğunu bu msdn makalesinden aldım .

Bu yardımcı olur umarım!

Numaralandırmalar derleme zamanında belirtilmelidir, çalışma zamanı sırasında dinamik olarak numaralandırmalar ekleyemezsiniz - ve neden kodda bunlara başvurulmasın?

Professional C # 2008'den:

C # 'daki numaralandırmaların gerçek gücü, perde arkasında System.Enum temel sınıfından türetilen yapılar olarak somutlaştırılmalarıdır. Bu, bazı yararlı görevleri gerçekleştirmek için onlara karşı yöntemler çağırmanın mümkün olduğu anlamına gelir. .NET Framework'ün uygulanma biçimi nedeniyle, numaralandırmaları sözdizimsel olarak yapılar olarak ele almakla ilişkili bir performans kaybı olmadığını unutmayın. Pratikte, kodunuz derlendikten sonra numaralandırmalar int ve float gibi ilkel türler olarak var olur.

Bu yüzden, Enums'i istediğiniz şekilde kullanabileceğinizden emin değilim.

Gerçek bir enum olmak zorunda mı? Dictionary<string,int>Bunun yerine a kullanmaya ne dersiniz ?

Örneğin

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

Bunu bir T4 şablonuyla yaptım . Bir .tt dosyasını projenize bırakmak ve T4 şablonunu bir ön derleme adımı olarak çalıştırmak için Visual Studio'yu ayarlamak oldukça önemsizdir.

T4 bir .cs dosyası oluşturur; bu, yalnızca veritabanını sorgulayıp sonuçtan bir .cs dosyasında bir enum oluşturmasını sağlayabileceğiniz anlamına gelir. Bir ön-oluşturma görevi olarak bağlanırsa, her derlemede numaranızı yeniden oluşturur veya bunun yerine T4'ü gerektiği gibi manuel olarak çalıştırabilirsiniz.

Diyelim ki DB'nizde aşağıdakiler var:

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 |
----------------------------------

İhtiyacınız olan değerleri elde etmek için bir seçim oluşturun:

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

Numaralandırma için kaynak kodunu oluşturun ve şöyle bir şey elde edersiniz:

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

(belli ki bu bir tür döngü içinde inşa edilmiştir.)

Sonra eğlenceli kısım gelir, numaranızı derlemek ve kullanmak:

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

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

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

Artık tür derlenmiş ve kullanıma hazırdır.
DB'de saklanan bir enum değerini almak için şunları kullanabilirsiniz:

[Enum].Parse(enumType, value);

burada değer, tamsayı değeri (0, 1, vb.) veya enum metni / anahtarı (Elma, Muz vb.)

Sadece Pandincus'un cevabını "rafın" kodu ve bazı açıklamalarla gösteriyorum: Bu örnek için iki çözüme ihtiyacınız var (bir tane ile de yapılabileceğini biliyorum;), ileri düzey öğrencilerin sunmasına izin verin ...

İşte tablo için DDL SQL:

USE [ocms_dev]
    GO

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

İşte dll'yi üreten konsol programı:

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 

İşte çıktıyı yazdıran Konsol programlama (dll'ye başvurması gerektiğini unutmayın). Öğrencilerin her şeyi tek bir çözümde dinamik yükleme ile birleştirmek ve halihazırda dll oluşturup oluşturmadığını kontrol etmek için çözümü sunmalarına izin verin.

// 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

Buna yanlış yönden gelmiyor muyuz?

Dağıtılan yayının ömrü boyunca verilerin değişme olasılığı varsa, o zaman bir enum uygun değildir ve bir sözlük, karma veya başka bir dinamik koleksiyon kullanmanız gerekir.

Dağıtılan yayının ömrü boyunca olası değerler kümesinin sabitlendiğini biliyorsanız, bir numaralandırma tercih edilir.

Veritabanınızda numaralandırılmış kümeyi çoğaltan bir şeye sahip olmanız gerekiyorsa , veritabanı tablosunu kesin enum değerleri kümesiyle temizlemek ve yeniden doldurmak için neden bir dağıtım adımı eklemeyesiniz?

Her zaman kendi "özel numaramı" yazmayı severim. Biraz daha karmaşık olan bir sınıfım var, ancak onu yeniden kullanabilirim:

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" );
    }
}

Şimdi sadece kullanmak istediğim numaramı oluşturmam gerekiyor:

 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; }
    }

Sonunda istediğim gibi kullanabiliyorum:

 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();
        }

Ve çıktım şöyle olacaktır:

Element1: foo
Is 'Element2': False

Element2: bar
Is 'Element2': True    

System.Web.Compilation.BuildProvider istiyorsunuz

Bunu yapmanın bilgeliğinden de şüphe duyuyorum, ama aklıma gelebilecek iyi bir kullanım durumu olabilir.

Aradığınız şey Yapı Sağlayıcıları yani System.Web.Compilation.BuildProvider

SubSonic tarafından çok etkili bir şekilde kullanılırlar , kaynağı indirebilir ve nasıl kullandıklarını görebilirsiniz, yaptıkları kadar karmaşık bir şeye ihtiyacınız olmayacak.

Bu yardımcı olur umarım.

Bunun gibi bir şey oluşturmak için CodeSmith'i kullanabilirsiniz:

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

İstediğini yapmanın iyi bir yolu olduğunu sanmıyorum. Ve eğer düşünürsen, gerçekten istediğinin bu olduğunu sanmıyorum.

Dinamik bir numaralandırmanız olacaksa, buna referans verirken onu dinamik bir değerle beslemeniz gerektiği anlamına da gelir. Belki çok fazla sihirle, bununla ilgilenecek ve bir DLL dosyasında sizin için bir enum oluşturacak bir tür IntelliSense elde edebilirsiniz . Ancak, gerekeceği iş miktarını, IntelliSense bilgilerini almak için veritabanına erişmenin ne kadar etkisiz olacağını ve oluşturulan DLL dosyasını kontrol eden sürümün kabusunu düşünün.

Numaralandırma değerlerini gerçekten manuel olarak eklemek istemiyorsanız (yine de bunları veritabanına eklemeniz gerekecek) bunun yerine bir kod oluşturma aracı, örneğin T4 şablonları kullanın. Sağ tıklama + çalıştırma ve numaralandırmanızı statik olarak kodda tanımlamış olursunuz ve numaralandırma kullanmanın tüm avantajlarından yararlanabilirsiniz.

Dinamik numaralandırmaları kullanmak, hangi şekilde olursa olsun kötüdür. Gelecekte bakımı kolay, temiz ve kolay kod sağlamak için verileri "çoğaltma" zahmetinden geçmeniz gerekecektir.

Otomatik olarak oluşturulmuş kitaplıkları uygulamaya başlarsanız, kodunuzu yükseltmek zorunda kalan gelecekteki geliştiriciler için, numaralandırmanızı uygun sınıf nesnesi içinde kodlamaktan daha fazla kafa karışıklığına neden olursunuz.

Verilen diğer örnekler kulağa hoş ve heyecan verici gelebilir, ancak kod bakımı üzerindeki ek yükü ve ondan ne elde ettiğinizi düşünün. Ayrıca, bu değerler o kadar sık ​​değişecek mi?

Enumları tutmanın ve aynı zamanda Dinamik bir değerler listesi oluşturmanın bir yolu, şu anda sahip olduğunuz Enümleri Dinamik olarak oluşturulmuş bir Sözlükle kullanmaktır.

Çoğu Enum, kullanılmak üzere tanımlandıkları bağlamda kullanıldığından ve "dinamik numaralandırmalar" dinamik işlemlerle destekleneceğinden, 2'yi ayırt edebilirsiniz.

İlk adım, Dinamik Girişler için ID'leri ve Referansları barındıran bir tablo / koleksiyon oluşturmaktır. Tabloda, en büyük Enum değerinizden çok daha büyük bir otomatik artış yapacaksınız.

Şimdi dinamik Enum'larınız için bir bölüm geliyor, Bir dizi kuralı uygulayan bir dizi koşul oluşturmak için Enums'i kullanacağınızı varsayıyorum, bazıları dinamik olarak üretilir.

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.

enum oluşturucu sınıfı

public class XEnum
{
    private EnumBuilder enumBuilder;
    private int index;
    private AssemblyBuilder _ab;
    private AssemblyName _name;
    public XEnum(string enumname)
    {
        AppDomain currentDomain = AppDomain.CurrentDomain;
        _name = new AssemblyName("MyAssembly");
        _ab = currentDomain.DefineDynamicAssembly(
            _name, AssemblyBuilderAccess.RunAndSave);

        ModuleBuilder mb = _ab.DefineDynamicModule("MyModule");

        enumBuilder = mb.DefineEnum(enumname, TypeAttributes.Public, typeof(int));


    }
    /// <summary>
    /// adding one string to enum
    /// </summary>
    /// <param name="s"></param>
    /// <returns></returns>
    public FieldBuilder add(string s)
    {
        FieldBuilder f = enumBuilder.DefineLiteral(s, index);
        index++;
        return f;
    }
    /// <summary>
    /// adding array to enum
    /// </summary>
    /// <param name="s"></param>
    public void addRange(string[] s)
    {
        for (int i = 0; i < s.Length; i++)
        {
            enumBuilder.DefineLiteral(s[i], i);
        }
    }
    /// <summary>
    /// getting index 0
    /// </summary>
    /// <returns></returns>
    public object getEnum()
    {
        Type finished = enumBuilder.CreateType();
        _ab.Save(_name.Name + ".dll");
        Object o1 = Enum.Parse(finished, "0");
        return o1;
    }
    /// <summary>
    /// getting with index
    /// </summary>
    /// <param name="i"></param>
    /// <returns></returns>
    public object getEnum(int i)
    {
        Type finished = enumBuilder.CreateType();
        _ab.Save(_name.Name + ".dll");
        Object o1 = Enum.Parse(finished, i.ToString());
        return o1;
    }
}

bir nesne yarat

string[] types = { "String", "Boolean", "Int32", "Enum", "Point", "Thickness", "long", "float" };
XEnum xe = new XEnum("Enum");
        xe.addRange(types);
        return xe.getEnum();