สร้าง Enum โดยอัตโนมัติตามค่าในตารางการค้นหาฐานข้อมูลหรือไม่

ฉันจะสร้าง enum โดยอัตโนมัติแล้วใช้ค่าใน C # ตามค่าในตารางการค้นหาฐานข้อมูลได้อย่างไร (โดยใช้ชั้นข้อมูลไลบรารีขององค์กร)

ตัวอย่างเช่นถ้าฉันเพิ่มค่าการค้นหาใหม่ในฐานข้อมูลฉันไม่ต้องการที่จะต้องเพิ่มการประกาศค่า enum แบบคงที่พิเศษในโค้ดด้วยตนเอง - ฉันต้องการให้ enum ซิงค์กับฐานข้อมูล

มีแบบนี้ด้วยเหรอ?

ฉันไม่ต้องการสร้างโค้ดที่สร้างแบบคงที่ enum (ตามบทความThe Code Project Enum Code Generator - การสร้างโค้ด enum โดยอัตโนมัติจากตารางค้นหาฐานข้อมูล ) และต้องการให้เป็นแบบอัตโนมัติโดยสมบูรณ์

ฉันกำลังทำสิ่งนี้อยู่ แต่คุณต้องสร้างรหัสบางอย่างเพื่อให้สิ่งนี้ใช้งานได้

ในโซลูชันของฉันฉันได้เพิ่มโปรเจ็กต์ "EnumeratedTypes" นี่คือแอปพลิเคชันคอนโซลที่รับค่าทั้งหมดจากฐานข้อมูลและสร้าง enums จากค่าเหล่านี้ จากนั้นจะบันทึก enums ทั้งหมดลงในแอสเซมบลี

รหัสการสร้าง 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");

โครงการอื่น ๆ ของฉันในโซลูชันอ้างอิงแอสเซมบลีที่สร้างขึ้นนี้ ด้วยเหตุนี้ฉันจึงสามารถใช้ไดนามิก enums ในโค้ดพร้อมด้วย intellisense

จากนั้นฉันจึงเพิ่มเหตุการณ์หลังการสร้างเพื่อที่หลังจากสร้างโปรเจ็กต์ "EnumeratedTypes" นี้มันจะรันเองและสร้างไฟล์ "MyEnums.dll"

โดยวิธีนี้จะช่วยในการเปลี่ยนลำดับการสร้างของโครงการของคุณเพื่อให้ "EnumeratedTypes" ถูกสร้างขึ้นก่อน มิฉะนั้นเมื่อคุณเริ่มใช้. dll ที่สร้างขึ้นแบบไดนามิกคุณจะไม่สามารถสร้างบิลด์ได้หาก. dll เคยถูกลบไป (ปัญหาประเภทไก่และไข่ - โครงการอื่น ๆ ของคุณในโซลูชันนี้ต้องการ. dll นี้เพื่อสร้างอย่างถูกต้องและคุณไม่สามารถสร้าง. dll ได้จนกว่าคุณจะสร้างโซลูชันของคุณ ... )

ฉันได้มากที่สุดของรหัสดังกล่าวจากบทความนี้ MSDN

หวังว่านี่จะช่วยได้!

ต้องระบุ Enums ในเวลาคอมไพล์คุณไม่สามารถเพิ่ม enums แบบไดนามิกระหว่างรันไทม์ได้และทำไมคุณถึงไม่มีการใช้ / การอ้างอิงในโค้ด?

จาก Professional C # 2008:

พลังที่แท้จริงของ enum ใน C # คือเบื้องหลังพวกมันถูกสร้างอินสแตนซ์เป็นโครงสร้างที่มาจากคลาสฐาน System.Enum ซึ่งหมายความว่าเป็นไปได้ที่จะเรียกวิธีการต่อต้านพวกเขาเพื่อทำงานที่มีประโยชน์ โปรดสังเกตว่าเนื่องจากวิธีการนำ. NET Framework ไปใช้งานจึงไม่มีการสูญเสียประสิทธิภาพที่เกี่ยวข้องกับการจัดการ enums ในเชิงไวยากรณ์เป็นโครงสร้าง ในทางปฏิบัติเมื่อคอมไพล์โค้ดของคุณ enums จะมีอยู่เป็นประเภทดั้งเดิมเช่นเดียวกับ int และ float

ดังนั้นฉันไม่แน่ใจว่าคุณสามารถใช้ Enums ในแบบที่คุณต้องการได้

มันต้องเป็น enum จริงหรือ? วิธีการใช้Dictionary<string,int>แทน?

ตัวอย่างเช่น

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

ฉันทำสิ่งนี้กับเทมเพลตT4แล้ว การวางไฟล์. tt ลงในโครงการของคุณเป็นเรื่องเล็กน้อยและตั้งค่า Visual Studio เพื่อเรียกใช้เทมเพลต T4 เป็นขั้นตอนก่อนสร้าง

T4 สร้างไฟล์. cs ซึ่งหมายความว่าคุณสามารถมีได้เพียงแค่สอบถามฐานข้อมูลและสร้าง enum ในไฟล์. cs จากผลลัพธ์ ต่อสายเป็นงานก่อนสร้างมันจะสร้าง enum ของคุณขึ้นมาใหม่ในทุกบิลด์หรือคุณสามารถรัน T4 ด้วยตนเองได้ตามต้องการแทน

สมมติว่าคุณมีสิ่งต่อไปนี้ในฐานข้อมูลของคุณ:

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

สร้างซอร์สโค้ดสำหรับ enum และคุณจะได้รับสิ่งต่อไปนี้:

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

(เห็นได้ชัดว่าสิ่งนี้ถูกสร้างขึ้นในลักษณะวนซ้ำ)

จากนั้นก็มาถึงส่วนที่สนุกสนานรวบรวม enum ของคุณและใช้มัน:

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 ที่เก็บไว้ในฐานข้อมูลคุณสามารถใช้:

[Enum].Parse(enumType, value);

โดยที่ค่าอาจเป็นค่าจำนวนเต็ม (0, 1 เป็นต้น) หรือข้อความ / คีย์ enum (Apple, Banana ฯลฯ )

เพียงแค่แสดง คำตอบของ 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

เรามาจากทิศทางที่ผิดไม่ใช่เหรอ?

หากข้อมูลมีแนวโน้มที่จะเปลี่ยนแปลงไปเลยในช่วงอายุการใช้งานของรีลีสที่ทำให้ใช้งานได้ enum ก็ไม่เหมาะสมและคุณจำเป็นต้องใช้พจนานุกรมแฮชหรือคอลเล็กชันแบบไดนามิกอื่น ๆ

หากคุณทราบว่าชุดของค่าที่เป็นไปได้ได้รับการแก้ไขสำหรับอายุการใช้งานของรีลีสที่ปรับใช้แล้ว enum จะดีกว่า

หากคุณต้องมีบางอย่างในฐานข้อมูลของคุณที่จำลองชุดที่แจกแจงแล้วทำไมไม่เพิ่มขั้นตอนการปรับใช้เพื่อล้างและเติมตารางฐานข้อมูลด้วยชุดค่า enum ที่ชัดเจน

ฉันชอบเขียน "custom enum" ของตัวเองเสมอ กว่าฉันจะมีคลาสเดียวที่ซับซ้อนกว่าเล็กน้อย แต่ฉันสามารถใช้ซ้ำได้:

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

ตอนนี้ฉันต้องสร้าง enum ของฉันที่ฉันต้องการใช้:

 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    

คุณต้องการ System.Web.Compilation.BuildProvider

ฉันยังสงสัยในภูมิปัญญาในการทำสิ่งนี้ แต่อาจมีกรณีการใช้งานที่ดีที่ฉันคิดไม่ถึง

สิ่งที่คุณกำลังมองหาคือBuild Providersเช่น System.Web.Compilation.BuildProvider

SubSonicใช้อย่างมีประสิทธิภาพมากคุณสามารถดาวน์โหลดซอร์สและดูว่าพวกเขาใช้มันอย่างไรคุณไม่จำเป็นต้องมีอะไรซับซ้อนเหมือนสิ่งที่พวกเขากำลังทำอยู่ครึ่งหนึ่ง

หวังว่านี่จะช่วยได้

คุณสามารถใช้ CodeSmith เพื่อสร้างสิ่งนี้:

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

ฉันไม่คิดว่าจะมีวิธีที่ดีในการทำสิ่งที่คุณต้องการ และถ้าคุณคิดอย่างนั้นฉันไม่คิดว่านี่คือสิ่งที่คุณต้องการจริงๆ

หากคุณมีไดนามิก enum ก็หมายความว่าคุณต้องป้อนค่าไดนามิกด้วยเมื่อคุณอ้างอิง บางทีด้วยความมหัศจรรย์มากมายคุณสามารถบรรลุIntelliSenseบางประเภทที่จะดูแลสิ่งนี้และสร้าง enum ให้คุณในไฟล์ DLL แต่ให้พิจารณาจำนวนงานที่ต้องใช้การเข้าถึงฐานข้อมูลเพื่อดึงข้อมูล IntelliSense ตลอดจนฝันร้ายของเวอร์ชันที่ควบคุมไฟล์ DLL ที่สร้างขึ้น

หากคุณไม่ต้องการเพิ่มค่า enum ด้วยตนเองจริงๆ (คุณจะต้องเพิ่มค่าเหล่านี้ในฐานข้อมูลอยู่ดี) ให้ใช้เครื่องมือสร้างรหัสแทนเช่นเทมเพลตT4 คลิกขวา + เรียกใช้และคุณได้รับ enum ที่กำหนดไว้ในโค้ดแบบคงที่และคุณจะได้รับประโยชน์ทั้งหมดจากการใช้ enums

การใช้ไดนามิก enums ไม่ดีไม่ว่าจะด้วยวิธีใดก็ตาม คุณจะต้องประสบปัญหาในการ "ทำซ้ำ" ข้อมูลเพื่อให้แน่ใจว่าโค้ดที่ชัดเจนและง่ายต่อการบำรุงรักษาง่ายในอนาคต

หากคุณเริ่มแนะนำไลบรารีที่สร้างขึ้นโดยอัตโนมัติคุณแน่นอนว่าจะทำให้เกิดความสับสนมากขึ้นกับนักพัฒนาในอนาคตที่ต้องอัปเกรดโค้ดของคุณมากกว่าเพียงแค่การเข้ารหัส enum ของคุณภายในออบเจ็กต์คลาสที่เหมาะสม

ตัวอย่างอื่น ๆ ให้เสียงที่ดีและน่าตื่นเต้น แต่ให้คิดถึงค่าใช้จ่ายในการบำรุงรักษาโค้ดเทียบกับสิ่งที่คุณได้รับจากมัน นอกจากนี้ค่าเหล่านี้จะเปลี่ยนแปลงบ่อยหรือไม่?

วิธีหนึ่งในการเก็บ Enums และสร้างรายการค่าแบบไดนามิกในเวลาเดียวกันคือการใช้ Enums ที่คุณมีอยู่ในพจนานุกรมที่สร้างขึ้นแบบไดนามิก

เนื่องจาก Enums ส่วนใหญ่ใช้ในบริบทที่กำหนดให้ใช้และ "ไดนามิก enums" จะได้รับการสนับสนุนโดยกระบวนการแบบไดนามิกคุณจึงสามารถแยกแยะ 2

ขั้นตอนแรกคือการสร้างตาราง / คอลเลกชันที่มี ID และการอ้างอิงสำหรับรายการแบบไดนามิก ในตารางคุณจะสร้างอัตโนมัติมากกว่าค่า 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.

คลาส builder enum

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

สร้างวัตถุ

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