Tạo một lớp động từ các loại được tìm nạp trong thời gian chạy

Có thể thực hiện các thao tác sau trong C # (hoặc bằng bất kỳ ngôn ngữ nào khác) không?

1. Tôi đang tìm nạp dữ liệu từ cơ sở dữ liệu. Trong thời gian chạy, tôi có thể tính toán số lượng cột và kiểu dữ liệu của các cột được tìm nạp.

2. Tiếp theo tôi muốn "tạo" một lớp với các kiểu dữ liệu này dưới dạng các trường. Tôi cũng muốn lưu trữ tất cả các hồ sơ mà tôi đã tìm nạp trong một bộ sưu tập.

Vấn đề là tôi muốn thực hiện cả bước 1 và 2 khi chạy

Điều này có thể không? Tôi hiện đang sử dụng C # nhưng tôi có thể chuyển sang thứ khác nếu tôi cần.

Sử dụng CodeDom. Đây là một cái gì đó để bắt đầu

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.CSharp;
using System.CodeDom.Compiler;
using System.CodeDom;

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            string className = "BlogPost";

            var props = new Dictionary<string, Type>() {
                { "Title", typeof(string) },
                { "Text", typeof(string) },
                { "Tags", typeof(string[]) }
            };

            createType(className, props);
        }

        static void createType(string name, IDictionary<string, Type> props)
        {
            var csc = new CSharpCodeProvider(new Dictionary<string, string>() { { "CompilerVersion", "v4.0" } });
            var parameters = new CompilerParameters(new[] { "mscorlib.dll", "System.Core.dll"}, "Test.Dynamic.dll", false);
            parameters.GenerateExecutable = false;

            var compileUnit = new CodeCompileUnit();
            var ns = new CodeNamespace("Test.Dynamic");
            compileUnit.Namespaces.Add(ns);
            ns.Imports.Add(new CodeNamespaceImport("System"));

            var classType = new CodeTypeDeclaration(name);
            classType.Attributes = MemberAttributes.Public;
            ns.Types.Add(classType);

            foreach (var prop in props)
            {
                var fieldName = "_" + prop.Key;
                var field = new CodeMemberField(prop.Value, fieldName);
                classType.Members.Add(field);

                var property = new CodeMemberProperty();
                property.Attributes = MemberAttributes.Public | MemberAttributes.Final;
                property.Type = new CodeTypeReference(prop.Value);
                property.Name = prop.Key;
                property.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldName)));
                property.SetStatements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldName), new CodePropertySetValueReferenceExpression()));
                classType.Members.Add(property);
            }

            var results = csc.CompileAssemblyFromDom(parameters,compileUnit);
            results.Errors.Cast<CompilerError>().ToList().ForEach(error => Console.WriteLine(error.ErrorText));
        }
    }
}

Nó tạo ra một hội đồng 'Test.Docate.dll' với lớp này trong đó

namespace Test.Dynamic
{
    public class BlogPost
    {
        private string _Title;
        private string _Text;
        private string[] _Tags;

        public string Title
        {
            get
            {
                return this._Title;
            }
            set
            {
                this._Title = value;
            }
        }
        public string Text
        {
            get
            {
                return this._Text;
            }
            set
            {
                this._Text = value;
            }
        }
        public string[] Tags
        {
            get
            {
                return this._Tags;
            }
            set
            {
                this._Tags = value;
            }
        }
    }
}

Bạn cũng có thể sử dụng các tính năng động của C #

Lớp DynamicEntity, không cần tạo bất cứ thứ gì khi chạy

public class DynamicEntity : DynamicObject
{
    private IDictionary<string, object> _values;

    public DynamicEntity(IDictionary<string, object> values)
    {
        _values = values;
    }
    public override IEnumerable<string> GetDynamicMemberNames()
    {
        return _values.Keys;
    }
    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
        if (_values.ContainsKey(binder.Name))
        {
            result = _values[binder.Name];
            return true;
        }
        result = null;
        return false;
    }
}

Và sử dụng nó như thế này

var values = new Dictionary<string, object>();
values.Add("Title", "Hello World!");
values.Add("Text", "My first post");
values.Add("Tags", new[] { "hello", "world" });

var post = new DynamicEntity(values);

dynamic dynPost = post;
var text = dynPost.Text;

Có, bạn có thể sử dụng phản xạ phát ra để làm điều này. Manning có những gì có vẻ là một cuốn sách tuyệt vời sắp ra mắt về điều này: Metaprogramming in .NET .

BTW: tại sao không sử dụng danh sách chứa từ điển hoặc tương tự để lưu trữ từng bản ghi với tên trường làm khóa?