クラスを動的に作成する方法は?


221

私はこのようなクラスを持っています:

public class Field
{
    public string FieldName;
    public string FieldType;
}

そしてList<Field>値を持つオブジェクト:

{"EmployeeID","int"},
{"EmployeeName","String"},
{"Designation","String"}

次のようなクラスを作成します。

Class DynamicClass
{
    int EmployeeID,
    String EmployeeName,
    String Designation
}

これを行う方法はありますか?

これを実行時に生成してください。ファイルシステムに物理的なCSファイルを配置したくありません。


4
そのクラスをランタイムで使用しますか、それともファイルのみを生成しますか?
DamianLeszczyński-

これを実行時に生成してほしい。私のファイルシステムに物理的なCSファイルを置きたくありません。先ほど言及しなかったことを申し訳ありません。
ashwnacharya 2010年

16
あなたは私たちにあなたがするつもり何をすべきかの目安与えることはできません。このクラスでは?
Justin

3
たとえば、@ Justinはランタイム解決インターフェースを実装します。
AgentFire、2014

にそれを与えることができますSystem.ServiceModel.ChannelFactory<MyDynamicInterface>
イリヤ・セメノフ

回答:


297

はい、System.Reflection.Emit名前空間を使用できます。経験がないのは簡単ではありませんが、それは確かに可能です。

編集:このコードは欠陥があるかもしれませんが、それはあなたに一般的な考えを与えて、うまくいけば目標に向かって良いスタートを切るでしょう。

using System;
using System.Reflection;
using System.Reflection.Emit;

namespace TypeBuilderNamespace
{
    public static class MyTypeBuilder
    {
        public static void CreateNewObject()
        {
            var myType = CompileResultType();
            var myObject = Activator.CreateInstance(myType);
        }
        public static Type CompileResultType()
        {
            TypeBuilder tb = GetTypeBuilder();
            ConstructorBuilder constructor = tb.DefineDefaultConstructor(MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);

            // NOTE: assuming your list contains Field objects with fields FieldName(string) and FieldType(Type)
            foreach (var field in yourListOfFields)
                CreateProperty(tb, field.FieldName, field.FieldType);

            Type objectType = tb.CreateType();
            return objectType;
        }

        private static TypeBuilder GetTypeBuilder()
        {
            var typeSignature = "MyDynamicType";
            var an = new AssemblyName(typeSignature);
            AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(an, AssemblyBuilderAccess.Run);
            ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MainModule");
            TypeBuilder tb = moduleBuilder.DefineType(typeSignature,
                    TypeAttributes.Public |
                    TypeAttributes.Class |
                    TypeAttributes.AutoClass |
                    TypeAttributes.AnsiClass |
                    TypeAttributes.BeforeFieldInit |
                    TypeAttributes.AutoLayout,
                    null);
            return tb;
        }

        private static void CreateProperty(TypeBuilder tb, string propertyName, Type propertyType)
        {
            FieldBuilder fieldBuilder = tb.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);

            PropertyBuilder propertyBuilder = tb.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null);
            MethodBuilder getPropMthdBldr = tb.DefineMethod("get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType, Type.EmptyTypes);
            ILGenerator getIl = getPropMthdBldr.GetILGenerator();

            getIl.Emit(OpCodes.Ldarg_0);
            getIl.Emit(OpCodes.Ldfld, fieldBuilder);
            getIl.Emit(OpCodes.Ret);

            MethodBuilder setPropMthdBldr =
                tb.DefineMethod("set_" + propertyName,
                  MethodAttributes.Public |
                  MethodAttributes.SpecialName |
                  MethodAttributes.HideBySig,
                  null, new[] { propertyType });

            ILGenerator setIl = setPropMthdBldr.GetILGenerator();
            Label modifyProperty = setIl.DefineLabel();
            Label exitSet = setIl.DefineLabel();

            setIl.MarkLabel(modifyProperty);
            setIl.Emit(OpCodes.Ldarg_0);
            setIl.Emit(OpCodes.Ldarg_1);
            setIl.Emit(OpCodes.Stfld, fieldBuilder);

            setIl.Emit(OpCodes.Nop);
            setIl.MarkLabel(exitSet);
            setIl.Emit(OpCodes.Ret);

            propertyBuilder.SetGetMethod(getPropMthdBldr);
            propertyBuilder.SetSetMethod(setPropMthdBldr);
        }
    }
}

2
驚くばかり!!CompileResultType()メソッドによって返されるタイプのオブジェクトを作成する方法も教えてください。
ashwnacharya

4
そのためにSystem.Activatorを使用できます。例を挙げて回答を更新します。
ダニエルズ

4
また、動的型のフィールドを検査、読み取り、更新するには、リフレクションを使用する必要があることにも注意してください。インテリセンスが必要でリフレクションが不要な場合は、動的クラスが継承し、キャストできる静的基本クラスまたはインターフェースが必要です。その場合、GetTypeBuilder()メソッドを変更し、moduleBuilder.DefineType呼び出しを変更して、静的型を最後のパラメーターとして含めることができます(現在はnull)
danijels

2
作成後のオブジェクトの使用方法を誰かが説明できますか
HELP_ME

3
@bugz上記のコードを使用してクラスを作成し、基本クラスでこのメソッドを追加できます。public void SetValue <T>(string name、T value){GetType()。GetProperty(name).SetValue(this、value ); }
stricq

71

多少の手間はかかりますが、不可能ではありません。

私がしたことは:

  • 文字列でC#ソースを作成します(ファイルに書き出す必要はありません)。
  • Microsoft.CSharp.CSharpCodeProvider(CompileAssemblyFromSource)で実行します
  • 生成されたタイプを見つける
  • そして、そのタイプのインスタンスを作成します(Activator.CreateInstance

この方法では、MSILを発行する代わりに、すでに知っているC#コードを処理できます。

しかし、これは、クラスがいくつかのインターフェイスを実装している(またはいくつかの基本クラスから派生している)場合に最適に機能します。


7
このディスカッションを見たいと思うかもしれません
nawfal 2014

1
@nawfalのashwnacharyaは、メンバーを元々リストに含んでいたクラスを実行時に動的に生成したいと考えていました。実行時に生成されたとしてもそれをファイルに入れることは良いパフォーマンスソリューションになるとは思いません。
sodjsn26fr

38

DynamicObjectを使用してクラスを動的に作成することもできます。

public class DynamicClass : DynamicObject
{
    private Dictionary<string, KeyValuePair<Type, object>> _fields;

    public DynamicClass(List<Field> fields)
    {
        _fields = new Dictionary<string, KeyValuePair<Type, object>>();
        fields.ForEach(x => _fields.Add(x.FieldName,
            new KeyValuePair<Type, object>(x.FieldType, null)));
    }

    public override bool TrySetMember(SetMemberBinder binder, object value)
    {
        if (_fields.ContainsKey(binder.Name))
        {
            var type = _fields[binder.Name].Key;
            if (value.GetType() == type)
            {
                _fields[binder.Name] = new KeyValuePair<Type, object>(type, value);
                return true;
            }
            else throw new Exception("Value " + value + " is not of type " + type.Name);
        }
        return false;
    }

    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
        result = _fields[binder.Name].Value;
        return true;
    }
}

私はすべてのクラスフィールドを、_fieldsそのタイプと値とともに辞書に格納します。どちらの方法でも、一部のプロパティの値を取得または設定できます。dynamicこのクラスのインスタンスを作成するには、キーワードを使用する必要があります。

あなたの例での使い方:

var fields = new List<Field>() { 
    new Field("EmployeeID", typeof(int)),
    new Field("EmployeeName", typeof(string)),
    new Field("Designation", typeof(string)) 
};

dynamic obj = new DynamicClass(fields);

//set
obj.EmployeeID = 123456;
obj.EmployeeName = "John";
obj.Designation = "Tech Lead";

obj.Age = 25;             //Exception: DynamicClass does not contain a definition for 'Age'
obj.EmployeeName = 666;   //Exception: Value 666 is not of type String

//get
Console.WriteLine(obj.EmployeeID);     //123456
Console.WriteLine(obj.EmployeeName);   //John
Console.WriteLine(obj.Designation);    //Tech Lead

編集:そしてこれが私のクラスの見え方Fieldです:

public class Field
{
    public Field(string name, Type type)
    {
        this.FieldName = name;
        this.FieldType = type;
    }

    public string FieldName;

    public Type FieldType;
}

1
コンストラクターでフィールドを初期化する必要があるまで、私はこのアプローチが好きでした。つまり、dynamic obj = new DynamicClass(fields){EmployeeId=123456;EmployeeName = "John"; Designation = "Tech Lead";}これを行うのは本当に素晴らしいことです。
rey_coder

14

私はこの古いタスクを再開することを知っていますが、c#4.0では、このタスクは絶対に簡単です。

dynamic expando = new ExpandoObject();
expando.EmployeeID=42;
expando.Designation="unknown";
expando.EmployeeName="curt"

//or more dynamic
AddProperty(expando, "Language", "English");

詳細については、https://www.oreilly.com/learning/building-c-objects-dynamicallyを参照して ください


はい。ただし、ここではタイプセーフが失われます。タイプセーフを維持しながら、同様のことを実行できますか?
toughQuestions

13

このような動的クラスの使用目的がわからないため、コード生成とランタイムコンパイルを実行できますが、多少の労力が必要です。多分匿名型が役立つでしょう:

var v = new { EmployeeID = 108, EmployeeName = "John Doe" };

7
フィールド名をハードコーディングすることはできません。彼は彼に彼らに提供していField.FieldNameます。フィールド名をハードコーディングする必要があると、目的が損なわれます。そうする必要がある場合は、クラスを作成することもできます。
toddmo 2016年

9

CodeDOMを確認したいとします。コード要素を定義してコンパイルすることができます。MSDNの引用:

...このオブジェクトグラフは、サポートされているプログラミング言語のCodeDOMコードジェネレーターを使用してソースコードとしてレンダリングできます。CodeDOMは、ソースコードをバイナリアセンブリにコンパイルするためにも使用できます。


これを実行時に生成してほしい。私のファイルシステムに物理的なCSファイルを置きたくありません。先ほど言及しなかったことを申し訳ありません。
ashwnacharya

1
@ashwnacharya:ソースファイルの生成と実行時のコンパイルの両方にCodeDOMを使用できます。
Hemant

1
ただし、CodeDOMコンパイラは生の文字列を取得するため、XSSおよびSQLインジェクションで使用されるものと同様の「コード挿入攻撃」を検討する必要がある場合があることに注意してください。
cwap

6

@danijelsの回答に基づいて、VB.NETでクラスを動的に作成します。

Imports System.Reflection
Imports System.Reflection.Emit

Public Class ObjectBuilder

Public Property myType As Object
Public Property myObject As Object

Public Sub New(fields As List(Of Field))
    myType = CompileResultType(fields)
    myObject = Activator.CreateInstance(myType)
End Sub

Public Shared Function CompileResultType(fields As List(Of Field)) As Type
    Dim tb As TypeBuilder = GetTypeBuilder()
    Dim constructor As ConstructorBuilder = tb.DefineDefaultConstructor(MethodAttributes.[Public] Or MethodAttributes.SpecialName Or MethodAttributes.RTSpecialName)

    For Each field In fields
        CreateProperty(tb, field.Name, field.Type)
    Next

    Dim objectType As Type = tb.CreateType()
    Return objectType
End Function

Private Shared Function GetTypeBuilder() As TypeBuilder
    Dim typeSignature = "MyDynamicType"
    Dim an = New AssemblyName(typeSignature)
    Dim assemblyBuilder As AssemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(an, AssemblyBuilderAccess.Run)
    Dim moduleBuilder As ModuleBuilder = assemblyBuilder.DefineDynamicModule("MainModule")
    Dim tb As TypeBuilder = moduleBuilder.DefineType(typeSignature, TypeAttributes.[Public] Or TypeAttributes.[Class] Or TypeAttributes.AutoClass Or TypeAttributes.AnsiClass Or TypeAttributes.BeforeFieldInit Or TypeAttributes.AutoLayout, Nothing)
    Return tb
End Function

Private Shared Sub CreateProperty(tb As TypeBuilder, propertyName As String, propertyType As Type)
    Dim fieldBuilder As FieldBuilder = tb.DefineField("_" & propertyName, propertyType, FieldAttributes.[Private])

    Dim propertyBuilder As PropertyBuilder = tb.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, Nothing)
    Dim getPropMthdBldr As MethodBuilder = tb.DefineMethod("get_" & propertyName, MethodAttributes.[Public] Or MethodAttributes.SpecialName Or MethodAttributes.HideBySig, propertyType, Type.EmptyTypes)
    Dim getIl As ILGenerator = getPropMthdBldr.GetILGenerator()

    getIl.Emit(OpCodes.Ldarg_0)
    getIl.Emit(OpCodes.Ldfld, fieldBuilder)
    getIl.Emit(OpCodes.Ret)

    Dim setPropMthdBldr As MethodBuilder = tb.DefineMethod("set_" & propertyName, MethodAttributes.[Public] Or MethodAttributes.SpecialName Or MethodAttributes.HideBySig, Nothing, {propertyType})

    Dim setIl As ILGenerator = setPropMthdBldr.GetILGenerator()
    Dim modifyProperty As Label = setIl.DefineLabel()
    Dim exitSet As Label = setIl.DefineLabel()

    setIl.MarkLabel(modifyProperty)
    setIl.Emit(OpCodes.Ldarg_0)
    setIl.Emit(OpCodes.Ldarg_1)
    setIl.Emit(OpCodes.Stfld, fieldBuilder)

    setIl.Emit(OpCodes.Nop)
    setIl.MarkLabel(exitSet)
    setIl.Emit(OpCodes.Ret)

    propertyBuilder.SetGetMethod(getPropMthdBldr)
    propertyBuilder.SetSetMethod(setPropMthdBldr)
End Sub

End Class

6

DynamicExpressionsを使用してクラスを動的に作成することもできます。

'Dictionary'にはコンパクトな初期化子があり、キーの衝突を処理するため、このようなことをしたいと思うでしょう。

  var list = new Dictionary<string, string> {
    {
      "EmployeeID",
      "int"
    }, {
      "EmployeeName",
      "String"
    }, {
      "Birthday",
      "DateTime"
    }
  };

または、JSONコンバーターを使用して、シリアル化された文字列オブジェクトを管理可能なものに構築することもできます。

次に、System.Linq.Dynamicを使用します。

  IEnumerable<DynamicProperty> props = list.Select(property => new DynamicProperty(property.Key, Type.GetType(property.Value))).ToList();

  Type t = DynamicExpression.CreateClass(props);

残りはSystem.Reflectionを使用しています。

  object obj = Activator.CreateInstance(t);
  t.GetProperty("EmployeeID").SetValue(obj, 34, null);
  t.GetProperty("EmployeeName").SetValue(obj, "Albert", null);
  t.GetProperty("Birthday").SetValue(obj, new DateTime(1976, 3, 14), null);
}  

4

プロパティ(つまりPOCO)だけの動的クラスを作成し、このクラスのリストを作成したい場合。後で提供されるコードを使用して、動的クラスを作成し、このリストを作成します。

var properties = new List<DynamicTypeProperty>()
{
    new DynamicTypeProperty("doubleProperty", typeof(double)),
    new DynamicTypeProperty("stringProperty", typeof(string))
};

// create the new type
var dynamicType = DynamicType.CreateDynamicType(properties);
// create a list of the new type
var dynamicList = DynamicType.CreateDynamicList(dynamicType);

// get an action that will add to the list
var addAction = DynamicType.GetAddAction(dynamicList);

// call the action, with an object[] containing parameters in exact order added
addAction.Invoke(new object[] {1.1, "item1"});
addAction.Invoke(new object[] {2.1, "item2"});
addAction.Invoke(new object[] {3.1, "item3"});

これは、前のコードが使用するクラスです。

注:Microsoft.CodeAnalysis.CSharpライブラリも参照する必要があります。

       /// <summary>
    /// A property name, and type used to generate a property in the dynamic class.
    /// </summary>
    public class DynamicTypeProperty
    {
        public DynamicTypeProperty(string name, Type type)
        {
            Name = name;
            Type = type;
        }
        public string Name { get; set; }
        public Type Type { get; set; }
    }

   public static class DynamicType
    {
        /// <summary>
        /// Creates a list of the specified type
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public static IEnumerable<object> CreateDynamicList(Type type)
        {
            var listType = typeof(List<>);
            var dynamicListType = listType.MakeGenericType(type);
            return (IEnumerable<object>) Activator.CreateInstance(dynamicListType);
        }

        /// <summary>
        /// creates an action which can be used to add items to the list
        /// </summary>
        /// <param name="listType"></param>
        /// <returns></returns>
        public static Action<object[]> GetAddAction(IEnumerable<object> list)
        {
            var listType = list.GetType();
            var addMethod = listType.GetMethod("Add");
            var itemType = listType.GenericTypeArguments[0];
            var itemProperties = itemType.GetProperties();

            var action = new Action<object[]>((values) =>
            {
                var item = Activator.CreateInstance(itemType);

                for(var i = 0; i < values.Length; i++)
                {
                    itemProperties[i].SetValue(item, values[i]);
                }

                addMethod.Invoke(list, new []{item});
            });

            return action;
        }

        /// <summary>
        /// Creates a type based on the property/type values specified in the properties
        /// </summary>
        /// <param name="properties"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public static Type CreateDynamicType(IEnumerable<DynamicTypeProperty> properties)
        {
            StringBuilder classCode = new StringBuilder();

            // Generate the class code
            classCode.AppendLine("using System;");
            classCode.AppendLine("namespace Dexih {");
            classCode.AppendLine("public class DynamicClass {");

            foreach (var property in properties)
            {
                classCode.AppendLine($"public {property.Type.Name} {property.Name} {{get; set; }}");
            }
            classCode.AppendLine("}");
            classCode.AppendLine("}");

            var syntaxTree = CSharpSyntaxTree.ParseText(classCode.ToString());

            var references = new MetadataReference[]
            {
                MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location),
                MetadataReference.CreateFromFile(typeof(DictionaryBase).GetTypeInfo().Assembly.Location)
            };

            var compilation = CSharpCompilation.Create("DynamicClass" + Guid.NewGuid() + ".dll",
                syntaxTrees: new[] {syntaxTree},
                references: references,
                options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));

            using (var ms = new MemoryStream())
            {
                var result = compilation.Emit(ms);

                if (!result.Success)
                {
                    var failures = result.Diagnostics.Where(diagnostic =>
                        diagnostic.IsWarningAsError ||
                        diagnostic.Severity == DiagnosticSeverity.Error);

                    var message = new StringBuilder();

                    foreach (var diagnostic in failures)
                    {
                        message.AppendFormat("{0}: {1}", diagnostic.Id, diagnostic.GetMessage());
                    }

                    throw new Exception($"Invalid property definition: {message}.");
                }
                else
                {

                    ms.Seek(0, SeekOrigin.Begin);
                    var assembly = System.Runtime.Loader.AssemblyLoadContext.Default.LoadFromStream(ms);
                    var dynamicType = assembly.GetType("Dexih.DynamicClass");
                    return dynamicType;
                }
            }
        }
    }

素晴らしいコード。動的リストでAddRangeも使用して、最終的に一度に複数のレコードを追加することはできますか?
RickyTad

2

あなたは仕事をすることができる動的モジュールとクラスを使って見ることができます。唯一の欠点は、アプリドメインに読み込まれたままになることです。しかし、使用されている.NETフレームワークのバージョンによって、それは変わる可能性があります。.NET 4.0は収集可能な動的アセンブリをサポートしているため、クラス/タイプを動的に再作成できます。


2

うわー!その答えをありがとう!いくつかの機能を追加して、あなたと共有する「datatable to json」コンバーターを作成しました。

    Public Shared Sub dt2json(ByVal _dt As DataTable, ByVal _sb As StringBuilder)
    Dim t As System.Type

    Dim oList(_dt.Rows.Count - 1) As Object
    Dim jss As New JavaScriptSerializer()
    Dim i As Integer = 0

    t = CompileResultType(_dt)

    For Each dr As DataRow In _dt.Rows
        Dim o As Object = Activator.CreateInstance(t)

        For Each col As DataColumn In _dt.Columns
            setvalue(o, col.ColumnName, dr.Item(col.ColumnName))
        Next

        oList(i) = o
        i += 1
    Next

    jss = New JavaScriptSerializer()
    jss.Serialize(oList, _sb)


End Sub

そして「compileresulttype」サブで、私はそれを変更しました:

    For Each column As DataColumn In _dt.Columns
        CreateProperty(tb, column.ColumnName, column.DataType)
    Next


Private Shared Sub setvalue(ByVal _obj As Object, ByVal _propName As String, ByVal _propValue As Object)
    Dim pi As PropertyInfo
    pi = _obj.GetType.GetProperty(_propName)
    If pi IsNot Nothing AndAlso pi.CanWrite Then
        If _propValue IsNot DBNull.Value Then
            pi.SetValue(_obj, _propValue, Nothing)

        Else
            Select Case pi.PropertyType.ToString
                Case "System.String"
                    pi.SetValue(_obj, String.Empty, Nothing)
                Case Else
                    'let the serialiser use javascript "null" value.
            End Select

        End If
    End If

End Sub


-1

Runtime Code Generation with JVM and CLR -ピーター・セストフト

このタイプのプログラミングに本当に興味がある人のために働きます。

あなたのための私のヒントは、あなたが何かを宣言する場合は文字列を避けようとするので、もしあなたがクラスフィールドを持っているなら、文字列よりもフィールドタイプを格納するためにクラスSystem.Typeを使う方が良いということです。そして、新しいクラスを作成するのではなく、最善の解決策として、新しいクラスを作成するのではなく、FiledInfoを作成してください。


2
リンクが死んでいる:-1
Glenn Slayden 2017

:グレン:迅速なグーグルでは作業リンクを明らかにしたpdfs.semanticscholar.org/326a/...
アンドレアスPardeike

@AndreasPardeikeありがとう、記事でそれを修復しました。
Glenn Slayden
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.