C# Erstellen einer dynamisch anonymen Typen (var)

Question

Ich muss einen anonymen Typ erstellen (hat eine Var sein). Wie folgt aus:

var sizes = new { 
    size = new { Medium = "1", Large = "-3", XL = "10%" } 
}; 

Es hat sich dynamisch sein, damit das nächste Mal das auch passieren könnte:

var sizes = new { 
    size = new { 3XL = "5", 4XL = "5%", 5XL = "-10%" } 
}; 

Wie mache ich dies in C# WinForms?

Wie fülle ich die Variablengrößen aus? Es muss in dieser Reihenfolge sein!

Answer 1

Sie können zur Laufzeit einen dynamischen Typ erstellen, der Methoden und Eigenschaften eines beliebigen Typs enthält, indem Sie System.Reflection.Emit verwenden. Sie können Ihren Eigenschaften innerhalb des erstellten dynamischen Typs Standardwerte zuweisen. Dies ist keine triviale Übung und es braucht etwas Arbeit, aber wenn Sie den Basiscode vollständig in Ihrem Code verwenden, ist es einfach.

Zuerst müssen Sie Ihren dynamischen Typ an Ihre aktuelle AppDomain anhängen.

private AssemblyName _assemblyName; 
private AssemblyBuilder _asssemblyBuilder; 

private ModuleBuilder _moduleBuilder; 
private Dictionary<SignatureBuilder, Type> _classes; 

private ReaderWriterLock _rwLock; 
private TypeBuilder _typeBuilder; 
private string _typeName; 

    /// <summary> 
    /// Default constructor. 
    /// </summary> 
    /// <param name="moduleName">The name of the assembly module.</param> 
    public DynamicTypeBuilder(string moduleName) 
    { 
     // Make sure the page reference exists. 
     if (moduleName == null) throw new ArgumentNullException("moduleName"); 

     // Create the nw assembly 
     _assemblyName = new AssemblyName(moduleName); 
     _asssemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(_assemblyName, AssemblyBuilderAccess.Run); 

     // Create only one module, therefor the 
     // modile name is the assembly name. 
     _moduleBuilder = _asssemblyBuilder.DefineDynamicModule(_assemblyName.Name); 

     // Get the class unique signature. 
     _classes = new Dictionary<SignatureBuilder, Type>(); 
     _rwLock = new ReaderWriterLock(); 
    } 

kann die dynamische Festigkeitsklasse

sein

/// <summary> 
/// Dynamic property builder, with value assigned. 
/// </summary> 
public class DynamicPropertyValue 
{ 
    object value; 
    string name; 
    Type type; 

    /// <summary> 
    /// Default constructor. 
    /// </summary> 
    /// <param name="name">The name of the property.</param> 
    /// <param name="type">The type of the property</param> 
    /// <param name="value">The value of the property.</param> 
    public DynamicPropertyValue(string name, Type type, object value) 
    { 
     if (name == null) throw new ArgumentNullException("name"); 
     if (type == null) throw new ArgumentNullException("type"); 
     if (value == null) throw new ArgumentNullException("value"); 
     this.name = name; 
     this.type = type; 
     this.value = value; 
    } 

    /// <summary> 
    /// Gets, the property name. 
    /// </summary> 
    public string Name 
    { 
     get { return name; } 
    } 

    /// <summary> 
    /// Gets, the property type. 
    /// </summary> 
    public Type Type 
    { 
     get { return type; } 
    } 

    /// <summary> 
    /// Gets, the property value. 
    /// </summary> 
    public object Value 
    { 
     get { return value; } 
    } 
} 

Die dynamische Methode Klasse

sein kann

/// <summary> 
/// Dynamic method builder. 
/// </summary> 
public class DynamicMethod 
{ 
    string name; 
    IEnumerable<Type> parameters; 
    Type returnType; 
    Action<TypeBuilder> buildAction = null; 

    /// <summary> 
    /// Default constructor. 
    /// </summary> 
    /// <param name="name">The name of the method.</param> 
    /// <param name="parameters">The collection parameter types.</param> 
    /// <param name="returnType">The return type.</param> 
    public DynamicMethod(string name, IEnumerable<Type> parameters, Type returnType) 
    { 
     if (name == null) throw new ArgumentNullException("name"); 

     this.name = name; 
     this.parameters = parameters; 
     this.returnType = returnType; 
    } 

    /// <summary> 
    /// Default constructor. 
    /// </summary> 
    /// <param name="name">The name of the method.</param> 
    /// <param name="parameters">The collection parameter types.</param> 
    /// <param name="returnType">The return type.</param> 
    /// <param name="buildAction">The build action.</param> 
    public DynamicMethod(string name, IEnumerable<Type> parameters, Type returnType, Action<TypeBuilder> buildAction) 
    { 
     if (name == null) throw new ArgumentNullException("name"); 

     this.name = name; 
     this.parameters = parameters; 
     this.returnType = returnType; 
     this.buildAction = buildAction; 
    } 

    /// <summary> 
    /// Gets, the method name. 
    /// </summary> 
    public string Name 
    { 
     get { return name; } 
    } 

    /// <summary> 
    /// Gets, the collection of parameters 
    /// </summary> 
    public IEnumerable<Type> Parameters 
    { 
     get { return parameters; } 
    } 

    /// <summary> 
    /// Gets, the return type. 
    /// </summary> 
    public Type ReturnType 
    { 
     get { return returnType; } 
    } 

    /// <summary> 
    /// Gets, build action. 
    /// </summary> 
    public Action<TypeBuilder> BuildAction 
    { 
     get { return buildAction; } 
    } 
} 

den Prozess erstellen starten.

/// <summary> 
    /// Create a new instance of the dynamic type. 
    /// </summary> 
    /// <param name="typeName">The name of the type.</param> 
    /// <param name="properties">The collection of properties to create in the type.</param> 
    /// <param name="methods">The collection of methods to create in the type.</param> 
    /// <returns>The new instance of the type.</returns> 
    public object Create(string typeName, IEnumerable<DynamicPropertyValue> properties, IEnumerable<DynamicMethod> methods) 
    { 
     // Make sure the page reference exists. 
     if (typeName == null) throw new ArgumentNullException("typeName"); 
     if (properties == null) throw new ArgumentNullException("properties"); 
     if (methods == null) throw new ArgumentNullException("methods"); 

     _typeName = typeName; 

     // Create the dynamic type collection 
     List<DynamicProperty> prop = new List<DynamicProperty>(); 
     foreach (DynamicPropertyValue item in properties) 
      prop.Add(new DynamicProperty(item.Name, item.Type)); 

     // Return the create type. 
     object instance = CreateEx(typeName, prop.ToArray(), methods); 
     PropertyInfo[] infos = instance.GetType().GetProperties(); 

     // Assign each type value 
     foreach (PropertyInfo info in infos) 
      info.SetValue(instance, properties.First(u => u.Name == info.Name).Value, null); 

     // Return the instance with values assigned. 
     return instance; 
    } 

Ist dies etwas ist, dass Sie den vollständigen Quellcode für den dynamischen Typ-Builder verwenden können https://github.com/nequeo/misc/blob/master/csharp/DynamicTypeBuilder.cs