如何使.net反射与动态生成的对象一起工作

Question

看下面的例子:

void Main()
{
    // APPROACH 1: With an anonymous type
    var myObject = new {
        Property1 = "PropertyValue1"
    };
    // WORKS: Properties contains "Property1"
    var properties = myObject.GetType().GetProperties();
    // APPROACH 2: With an expando object
    dynamic myObject2 = new ExpandoObject();
    myObject2.Property1 = "PropertyValue1";
    // DOES NOT WORK: Properties2 is null or empty
    var properties2 = myObject2.GetType().GetProperties();
}

我想要的是使Type.GetProperties()在动态生成的类型上工作。我真的理解为什么它适用于方法1而不是方法2。实际上，在方法1中，编译器有机会生成与命名类型完全相似的匿名类型。但是，在方法2中，编译时类型实际上是ExpandoObject，因此反射不能正常工作。

我如何创建一个运行时对象，这是动态的，也将正常工作与反射，像GetProperties方法?

编辑

感谢所有的答案，但我真的理解，我知道如何从ExpandoObject获得键和值。问题是，我需要将动态创建的实例传递给我控制之外的方法，该方法将依次调用实例上的GetProperties()。

Answer 1

您不需要反射ExpandoObject。它实际上只是IDictionary<string, object>的一个奇特的实现。您可以这样强制转换它，然后您将拥有一个字典，其中键是属性名称，值是属性值:

// Create your object
dynamic myObject2 = new ExpandoObject();
// Cast to IDictionary<string, object>
var myObjectDictionary = (IDictionary<string, object>)myObject2;
// Get List<string> of properties
var propertyNames = myObjectDictionary.Keys.ToList();

另一种选择是使用IDynamicMetaObjectProvider的特性，ExpandoObject也实现了这些特性。用法如下:

var metaObjectProvider = (IDynamicMetaObjectProvider)myObject2;
var propertyNames = metaObjectProvider
    .GetMetaObject(Expression.Constant(metaObjectProvider))
    .GetDynamicMem‌​berNames();

在本例中，propertyNames将是具有动态成员名的IEnumerable<string>。

Answer 2

为了通过反射获得动态构造类型的值，您需要使用Reflection.Emit。这并不理想，因为它要求您正确地发出MSIL。如果您的用例只需要简单的属性访问，那么它可能是可行的，尽管不明智。

下面是一个简单的、经过少量测试的类型构建器，它使用Reflection.Emit:

    public static class TypeBuilderUtil {
        public static Type BuildDynamicType() {
            var typeBuilder = CreateTypeBuilder( "DynamicType" );
            CreateProperty( typeBuilder, "Property1", typeof ( string ) );
            var objectType = typeBuilder.CreateType();
            return objectType;
        }
        private static TypeBuilder CreateTypeBuilder( string typeName ) {
            var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly( new AssemblyName( "DynamicAssembly" ), AssemblyBuilderAccess.Run );
            var moduleBuilder = assemblyBuilder.DefineDynamicModule( "DynamicModule" );
            var typeBuilder = moduleBuilder.DefineType( typeName,
                                                        TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit | TypeAttributes.AutoLayout
                                                        , null );
            return typeBuilder;
        }
        private static void CreateProperty( TypeBuilder typeBuilder, string propertyName, Type propertyType ) {
            var backingFieldBuilder = typeBuilder.DefineField( "_" + propertyName, propertyType, FieldAttributes.Private );
            var propertyBuilder = typeBuilder.DefineProperty( propertyName, PropertyAttributes.HasDefault, propertyType, null );
            // Build setter
            var getterMethodBuilder = typeBuilder.DefineMethod( "get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType, Type.EmptyTypes );
            var getterIl = getterMethodBuilder.GetILGenerator();
            getterIl.Emit( OpCodes.Ldarg_0 );
            getterIl.Emit( OpCodes.Ldfld, backingFieldBuilder );
            getterIl.Emit( OpCodes.Ret );
            // Build setter
            var setterMethodBuilder = typeBuilder.DefineMethod( "set_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null, new[] {propertyType} );
            var setterIl = setterMethodBuilder.GetILGenerator();
            setterIl.Emit( OpCodes.Ldarg_0 );
            setterIl.Emit( OpCodes.Ldarg_1 );
            setterIl.Emit( OpCodes.Stfld, backingFieldBuilder );
            setterIl.Emit( OpCodes.Ret );
            propertyBuilder.SetGetMethod( getterMethodBuilder );
            propertyBuilder.SetSetMethod( setterMethodBuilder );
        }
    }

您将创建类型，然后像这样填充:

        var myType = TypeBuilderUtil.BuildDynamicType();
        var myObject = Activator.CreateInstance( myType );
        // Set the value
        var propertyInfo = myObject.GetType().GetProperty( "Property1", BindingFlags.Instance | BindingFlags.Public );
        propertyInfo.SetValue( myObject, "PropertyValue", null );

Answer 3

第一个例子是一个匿名对象。编译器实际上在后台生成一个类型，您可以对其进行反思。

第二个示例使用ExpandoObject来支持动态对象。ExpandoObject没有自己的属性，这就是为什么你的调用返回它所做的。ExpandoObject显式地实现了IDictionary<string, object>，使您可以访问属性及其值。你可以这样使用它:

var properties2 = (myObject2 as IDictionary<string, object>).Keys;

Answer 4

ExpandoObject是这里的特殊之处，没有其他。它实际上并没有在运行时改变类型本身的定义。这里实际发生的事情是，表面上的属性访问实际上是在改变在幕后持有的IDictionary<string,object>。要访问ExpandoObject的属性(注意，这对任何其他类型都不起作用)，您可以将其强制转换为IDictionary<string,object>，这是从ExpandoObject获取数据的预期机制。