Question

考虑以下代码

 var currentType = Type.GetType("Some.Type, Some");
 dynamic myDynamic = new System.Dynamic.ExpandoObject();
 myDynamic.A = "A";
 var objectInCorrectType = ???

如何将动态转换为currentType？

Answer 1

您无法将动态对象强制转换为特定类型，如@Lasse所述。

但是，你的问题提到“反思”，所以我怀疑你正在寻找一种方法来简单地映射属性值（即在Lasse的评论中“创建一个新的X并复制值等”）：

...
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]);

Answer 2

dynamic是duck-typing一个变量（即延迟类型检查到运行时）。它仍然包含一个类型化的对象，但在编译期间不会检查它。

因此，由于ExpandoObject是一种类型，如果您将其分配给类型化或动态引用，则无法将ExpandoObject转换或转换为类型，因为它共享与目标类型相同的成员。

顺便说一下，由于ExpandoObject实现了IDictionary<string, object>，您可以实现从ExpandoObject实例到成员匹配的目标类型的某种即时映射作为扩展方法：

public static class ExpandObjectExtensions
{
    public static TObject ToObject<TObject>(this IDictionary<string, object> someSource, BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public)
           where TObject : class, new ()
    {
        Contract.Requires(someSource != null);
        TObject targetObject = new TObject();
        Type targetObjectType = typeof (TObject);

        // Go through all bound target object type properties...
        foreach (PropertyInfo property in 
                    targetObjectType.GetProperties(bindingFlags))
        {
            // ...and check that both the target type property name and its type matches
            // its counterpart in the ExpandoObject
            if (someSource.ContainsKey(property.Name) 
                && property.PropertyType == someSource[property.Name].GetType())
            {
                property.SetValue(targetObject, someSource[property.Name]);
            }
        }

        return targetObject;
    }
}

现在，请尝试以下代码，它将按预期运行：

public class A 
{
    public int Val1 { get; set; }
}

// Somewhere in your app...
dynamic expando = new ExpandoObject();
expando.Val1 = 11;

// Now you got a new instance of A where its Val1 has been set to 11!
A instanceOfA = ((ExpandoObject)expando).ToObject<A>();

实际上，我已将此答案基于其他Q＆amp; A，我可以解决将对象映射到字典的相似问题，反之亦然：Mapping object to dictionary and vice versa 。

Answer 3

我遇到了这个问题，因为我需要参加这样的课程：

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

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

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

并将对象的PropertyArray属性（使用Newtonsoft库从JSON反序列化）转换为特定类型的对象数组，该类型的对象可以从PropertyName派生。

我编写了一个名为DynamicCast<>的帮助程序类，并决定将其发布在这里，以防其他任何人处于与我相同的情况。

该帮助器类使您可以编写如下代码：

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'

这是我如何使用它来解决反序列化问题的示例：

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'

基于此处的其他答案，作者编写了DynamicCast类。看起来像这样：

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;
    }
}

您可以在.Net小提琴中自行尝试：https://dotnetfiddle.net/J1JXgU

使用反射c＃将动态对象转换为类型

3 个答案: