通过反射处理泛型属性

Question

如果我有以下包装类：

public class Wrapper<T>
{
    public T Data { get; set; }
    public string[] Metadata { get;set;
}

然后另一个类在没有泛型的情况下公开该值：

public class SomeOtherClass
{
    public object WrappedData { get;set };
}

，我怎样才能得到原始的解包数据？

我可以测试它，使用类似的东西：

if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Wrapper<>))
{
    dynamic originalValue = someOtherClass.WrappedData;
}

但我不能在originalValue 上调用.Data 属性，得到RuntimeBinderException。

---

更新

更多的上下文可能会有所帮助。我正在开发一个想要实现 HATEOAS 的 WebAPI。所以我的包装类包含将返回的数据和元数据，我正在编写一个动作过滤器，它将解包数据，在响应正文中返回它，并将元数据放入响应标头中。动作过滤器目前实现如下：

public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
{
    if (actionExecutedContext.Request.Method == HttpMethod.Get)
    {
        var objectContent = actionExecutedContext.Response.Content as ObjectContent;
        if (objectContent != null)
        {
        var type = objectContent.ObjectType;
        var formatter = actionExecutedContext
            .ActionContext
            .ControllerContext
            .Configuration
            .Formatters
            .First(f => f.SupportedMediaTypes
                .Contains(new MediaTypeHeaderValue(actionExecutedContext
                    .Response
                    .Content
                    .Headers
                    .ContentType
                    .MediaType)));

            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Wrapper<>))
            {
                dynamic value = objectContent.Value;
                actionExecutedContext.Response.Content = new ObjectContent(value.Data.GetType(), value.Data, formatter);
            }
        }
    }

    base.OnActionExecuted(actionExecutedContext);
}

显然，当前并非我所有的 API 端点都包装了它们的数据，所以如果响应没有返回 Wrapper<T> 实例，我想退出操作过滤器而不修改响应。如果是，则取出.Data的值，并用它重写响应体。

Answer 1

从贴出的代码中并不清楚objectContent.ObjectType是什么，所以我会修改代码以检查实际值：

object value = objectContent.Value;
if (value != null && value.GetType().IsGenericType && value.GetType().GetGenericTypeDefinition() == typeof(Wrapper<>))
{
    object data = ((dynamic)value).Data;
    actionExecutedContext.Response.Content = new ObjectContent(data.GetType(), data, formatter);
}

但是，如果您使用非泛型接口备份泛型类，则可以避免反射和动态调用，并使您的生活更轻松。比如

public interface IWrapper
{
    object Data { get; }
    string[] Metadata { get; }
}

public class Wrapper<T> : IWrapper
{
    public T Data { get; set; }
    object IWrapper.Data { get { return Data; } }
    public string[] Metadata { get; set; }
}

那么你就可以做简单的了

var wrapper = objectContent.Value as IWrapper;
if (wrapper != null)
{
    actionExecutedContext.Response.Content = new ObjectContent(wrapper.Data.GetType(), wrapper.Data, formatter);
}

Answer 2

以下代码有效：

using System;

namespace ConsoleApplication1
{
    class Program
    {

        public class Wrapper<T>
        {
            public T Data { get; set; }
            public string[] Metadata
            {
                get; set;
            }

        }

        public class SomeOtherClass
        {
            public object WrappedData { get; set; }
        }


        static void Main(string[] args)
        {
            var wrappedData = new Wrapper<int> { Data = 3 };
            var someObject = new SomeOtherClass { WrappedData = wrappedData };

            dynamic d = someObject.WrappedData;
            Console.WriteLine(d.Data);

        }
    }
}

所以，不清楚你的问题是什么！

Answer 3

如果您将类型添加到包装器中会有帮助吗？

public class Wrapper<T>
{
    public Type MyType{get;set;}
    public T Data { get; set; }
    public string[] Metadata { get;set;}

    public Wrapper(T data){
      MyType = data.GetType();
      Data = data; 
    }
}

Answer 4

不清楚你到底想做什么：

object obj = new Wrapper<SomeOtherClass> { Data = new SomeOtherClass { WrappedData = "Hello" } };
Type type = obj.GetType();

if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Wrapper<>))
{
    dynamic data = ((dynamic)obj).Data;
    dynamic wrappedData = data.WrappedData;
}

请注意，不能保证Data 属性中存在WrappedData 属性：WrappedData 是SomeOtherClass 的属性，但例如obj 可能是：

object obj = new Wrapper<string> { Data = "Hello" };