Die Generierung von dynamischen Objekt aus dem Wörterbuch mit C # Reflexion

Ich habe forschen ein wenig über reflections in C # und würde gerne wissen, ob ich ein Wörterbuch mit Schlüssel-Werte erstellen können, die ein Objekt mit der variable mit dem Namen, der jeden Schlüssel im dictionary und Ihrer Werte, der Schlüssel Wert, Wörterbuch.

Habe ich eine Methode, die genau das Gegenteil tut, extrahieren eines Objekts aus einem Wörterbuch dieses Wörterbuch enthält die Schlüssel und die Eigenschaften der Klasse und Ihrer Werte, der Wert der Eigenschaften.

Frage ich mich, wie Sie dies tun, wenn möglich.

Unten ist meine Methode, die Auszüge eines Wörterbuchs, die ein Objekt:

protected Dictionary<String, String> getObjectProperty(object objeto)
{
    Dictionary<String, String> dictionary = new Dictionary<String, String>();

    Type type = objeto.GetType();
    FieldInfo[] field = type.GetFields();
    PropertyInfo[] myPropertyInfo = type.GetProperties();

    String value = null;

    foreach (var propertyInfo in myPropertyInfo)
    {
        if (propertyInfo.GetIndexParameters().Length == 0)
        {
            value = (string)propertyInfo.GetValue(objeto, null);
            value = value == null ? null : value;
            dictionary.Add(propertyInfo.Name.ToString(), value);
        }
    }

    return dictionary;
}
Meinst du "dynamic" - typisierte Objekt? Oder neue Art?
Welche version von .NET framework, die Sie verwenden?
Das Objekt ist bereits vorhanden, wenn diese Funktion verlassen, ich muss nur gegossen (myObject) das Ergebnis an das bestehende Objekt. .NET 4.0
Kann sein, dass das ist, was Sie suchen [Konvertieren Dictionary<string, object> Anonymes Objekt?][1] [1]: stackoverflow.com/questions/7595416/...

InformationsquelleAutor Elton da Costa | 2013-08-17

  1. 12

    Wenn Sie bereits ein Wörterbuch, ich möchte vermeiden, Reflexion und verwenden nur DynamicObject

    Beispiel:

    public class DynamicDictionary : DynamicObject
{
    private readonly Dictionary<string, object> dictionary;

    public DynamicDictionary(Dictionary<string, object> dictionary)
    {
        this.dictionary = dictionary;
    }

    public override bool TryGetMember(
        GetMemberBinder binder, out object result)
    {
        return dictionary.TryGetValue(binder.Name, out result);
    }

    public override bool TrySetMember(
        SetMemberBinder binder, object value)
    {
        dictionary[binder.Name] = value;

        return true;
    }
}

    Kann wie folgt verwendet werden:

    dynamic x = new DynamicDictionary(
    new Dictionary<string, object> {{"Name", "Peter"}});

Console.WriteLine(x.Name);

    InformationsquelleAutor Peter Ritchie

  2. 2

    Ich bin nicht sicher, ob dies ist, was Sie suchen, aber die Beurteilung durch Ihre Frage, ich denke, Sie wollen
    instanziieren von Typen zur Laufzeit anhand der Typen befindet sich in einem Wörterbuch, die erhalten werden, indem eine Taste.

    Wenn das so ist, dann erstellen Sie die folgende Klasse, die halten die Schlüssel-Wert-Paare von strings, das zu Ihrem Schlüssel, und Typen repräsentieren Ihre Werte, die instanziiert werden.

    class DictionaryActivator
{
    Dictionary<string, Type> Dictionary = new Dictionary<string, Type>();

    public DictionaryActivator()
    {
        Dictionary.Add("MyCar", typeof(Car));
        Dictionary.Add("MyHouse", typeof(House));
        Dictionary.Add("MyFruit", typeof(Fruit));
        Dictionary.Add("MyComputer", typeof(Computer));
    }

    public T GetInstance<T>(string type, params object[] parameters)
    {
        if (parameters.Count() == 0)
        {
            return (T)Activator.CreateInstance(Dictionary[type]);
        }
        else
        {
            return (T)Activator.CreateInstance(Dictionary[type], parameters.ToArray());
        }
    }
}

    Können Sie auch vier test Klassen zu testen, dieses setup.

    class House
{
    public int Number = 25;
}

class Car
{
    public double Price = 50000;
}

class Fruit
{
    public string Name = "Apple";
}

class Computer
{
    public string Cpu { get; set; }
    public string Gpu { get; set; }

    public Computer(string cpu, string gpu)
    {
        Cpu = cpu;
        Gpu = gpu;
    }
}

    Sobald dies erledigt ist, führen Sie die folgenden Zeilen code, um alle Arten aus dem Wörterbuch, instanziieren Sie und warfen Sie auf geeignete Arten. Wie Sie vielleicht bemerkt, die letzten Computer Beispiel zeigt Ihnen, wie Sie mehrere Parameter (in diesem Fall zwei) auf die neu erstellte Instanz und schicken Sie es als eine Instanz des Typs Objekt.

    In das Ende können Sie werfen es auf die Computer geben, so dass Sie überprüfen können, dass die Konstruktor-Parameter ging tatsächlich zu den entsprechenden Eigenschaften.

    class Program
{
    static void Main()
    {
        var source = new DictionaryActivator();

        Console.WriteLine(source.GetInstance<Car>("MyCar").Price);
        Console.WriteLine(source.GetInstance<House>("MyHouse").Number);
        Console.WriteLine(source.GetInstance<Fruit>("MyFruit").Name);

        var computer = source.GetInstance<object>("MyComputer", "Fast CPU", "Fast GPU");

        Console.WriteLine((computer as Computer).Cpu);
        Console.WriteLine((computer as Computer).Gpu);

        Console.Read();
    }
}
    Erzeuge ich ein Objekt vom Typ Objekt, und fügen Sie z.B. zwei Variablen mit Ihren Werten und zurückgeben?
    Ich bearbeitet meine Antwort also ja ist, können Sie genau das tun. Geben Sie nur so viele Parameter, die Sie möchten, um Ihre neue Instanz und wirf ihn auf ein Objekt durch Verwendung der generischen Typ definiert auf die GetInstance - <T>(string, params object []) - Methode.

    InformationsquelleAutor Mario Stopfer

  3. 1

    Seit ExpandoObject ist ein Wörterbuch, können Sie mit dieser Erweiterung Funktion:

    public static object With(this IDictionary<string, object> obj, IDictionary<string,object> additionalProperties)
{
  foreach (var name in additionalProperties.Keys)
    obj[name] = additionalProperties[name];
  return obj;
}

    Verwendung:

    var dynamicObj = new System.Dynamic.ExpandoObject().With(myDictionary);

    InformationsquelleAutor toddmo

Schreibe einen Kommentar