Cast dynamische Objekt-Typ unter Verwendung von reflektion ab c#

Können Sie nicht wirken ein dynamisches Objekt zu einem bestimmten Typ, wie @Lasse kommentiert.

Jedoch in Ihrer Frage erwähnt, "Reflexion", also ich vermute, du suchst eine Möglichkeit, einfach map-Werte (d.h. "erstellen einer neuen X und kopieren über Werte, etc." in lasses Kommentar):

...
myDynamic.A = "A";

//get settable public properties of the type
var props = currentType.GetProperties(BindingFlags.Public | BindingFlags.Instance)
    .Where(x => x.GetSetMethod() != null);

//create an instance of the type
var obj = Activator.CreateInstance(currentType);

//set property values using reflection
var values = (IDictionary<string,object>)myDynamic;
foreach(var prop in props)
    prop.SetValue(obj, values[prop.Name]);

Kam ich über diese Frage, weil ich brauchte, um eine Klasse wie folgt aus:

public class PropertyChange
{
    [JsonProperty("name")]
    public string PropertyName { get; set; }

    [JsonProperty("value")]
    public string PropertyValue { get; set; }

    [JsonProperty("arrayValue")]
    public dynamic[] PropertyArray { get; set; }
}

konvertieren und die PropertyArray Eigenschaft eines Objekts (Deserialisierung von JSON mit der Newtonsoft-Bibliothek) in ein array von Objekten eines bestimmten Typs, wo der Typ kann abgeleitet werden, aus der PropertyName.

Schrieb ich diese helper-Klasse namens DynamicCast<> und beschlossen, es hier zu posten falls jemand anders in der gleichen situation wie ich.

Diese helper-Klasse ermöglicht es Ihnen, code zu schreiben, wie diese:

public class MyType
{
    public string A { get; set; }
}

var myCast = new DynamicCast<MyType>();

dynamic dyn = ExpandoObject();
dyn.A = "Hello";

var myType = myCast.Cast(dyn);
Console.WriteLine(myType.A); //prints 'Hello'

Dies ist ein Beispiel, wie ich es zur Lösung meiner Deserialisierung problem:

public class JsonTest
{
    [JsonProperty("theArray")]
    public dynamic[] TheArray { get; set; }
}

var json = "{'theArray':[{'a':'First'},{'a':'Second'}]}";
var jsonTest = JsonConvert.DeserializeObject<JsonTest>(json);

var myCast = new DynamicCast<MyType>();
var myTypes = myCast.Cast(jsonTest.TheArray).ToArray();
Console.WriteLine(myTypes[0].A); //prints 'First'

Den schrieb der DynamicCast Klasse basierend auf andere Antworten hier. Es sieht wie folgt aus:

public class DynamicCast<T> where T: class, new()
{
    private Property[] _proprties;

    public DynamicCast()
    {
        _proprties = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance)
            .Where(x => x.GetSetMethod() != null)
            .Where(x => x.GetGetMethod() != null)
            .Select(p =>
            {
                var property = new Property
                {
                    PropertyInfo = p,
                    Name = p.Name
                };
                foreach (var attribute in p.GetCustomAttributes(false))
                {
                    if (attribute.GetType() == typeof(JsonPropertyAttribute))
                    {
                        var jsonProperty = (JsonPropertyAttribute)attribute;
                        property.Name = jsonProperty.PropertyName;
                        break;
                    }
                    if (attribute.GetType() == typeof(JsonIgnoreAttribute))
                    {
                        return null;
                    }
                }
                return property;
            })
            .Where(p => p != null)
            .ToArray();
    }

    public T Cast(IDictionary<string, object> d)
    {
        var t = new T();
        Fill(d, t);
        return t;
    }

    public T Cast(JObject d)
    {
        var t = new T();
        Fill(d, t);
        return t;
    }

    public dynamic Cast(T t)
    {
        dynamic d = new ExpandoObject();
        Fill(t, d);
        return d;
    }

    public IEnumerable<T> Cast(IEnumerable<JObject> da)
    {
        return da.Select(e => Cast(e));
    }

    public IEnumerable<T> Cast(IEnumerable<object> da)
    {
        return da.Select(e =>
        {
            if (e is JObject) return Cast((JObject)e);
            if (e is IDictionary<string, object>) return Cast((IDictionary<string, object>)e);
            return null;
        });
    }

    public void Fill(IDictionary<string, object> values, T target)
    {
        foreach (var property in _proprties)
            if (values.TryGetValue(property.Name, out var value))
                property.PropertyInfo.SetValue(target, value, null);
    }

    public void Fill(JObject values, T target)
    {
        foreach (var property in _proprties)
        {
            if (values.TryGetValue(property.Name, out var value))
            {
                if (value is JValue jvalue)
                {
                    var propertyValue = Convert.ChangeType(jvalue.Value, property.PropertyInfo.PropertyType);
                    property.PropertyInfo.SetValue(target, propertyValue, null);
                }
            }
        }
    }

    public void Fill(T obj, IDictionary<string, object> target)
    {
        foreach (var property in _proprties)
            target[property.Name] = property.PropertyInfo.GetValue(obj, null);
    }

    private class Property
    {
        public PropertyInfo PropertyInfo;
        public string Name;
    }
}

Können Sie versuchen, diese für sich selbst in .Net Fiddle hier: https://dotnetfiddle.net/J1JXgU