.NET运行时解析泛型接口方法返回类型的依赖问题

现有实现方式 #

我之前通过让各数据源处理器返回序列化字符串的方式实现需求，示例代码如下（Orders数据和Users数据分别来自不同系统）：

public interface IProcessor<IData> {
    public string GetData(IData source);
}

public interface IData {
    public string Name { get; }
    public string ApiUrl { get; }
}

public class OrdersDataProcessor: IProcessor<IData> {
    public string GetData(IData source) {
        // 从数据源请求数据
        var results = source.ApiUrl;
        var data = new object { };

        return JsonConvert.SerializeObject(data);
    }
}

public class UsersDataProcessor : IProcessor<IData> {
    public string GetData(IData source) {
        // 从数据源请求数据
        var results = source.ApiUrl;
        var data = new object { };

        return JsonConvert.SerializeObject(data);
    }
}

注册处理器的方式：

Container.RegisterType<IProcessor<IData>,OrdersDataProcessor>("orders");
Container.RegisterType<IProcessor<IData>,UsersDataProcessor>("users");

由于数据源数量可能很多，我将需要的组合配置存储在数据库中，然后创建服务来解析依赖并调用GetData方法：

public interface IDataAgreggator {
    public IEnumerable<IData> Sources { get; set; }        
}

public class ProcessDataService {
    private readonly IUnityContainer unity;
    public ProcessDataService(IUnityContainer unity) {
        this.unity = unity;
    }

    public void ProcessData(IDataAgreggator agreggator) {
        foreach (var source in agreggator.Sources) {

            var processor = unity.Resolve<IProcessor>(source.Name);

            var data = processor.GetData();

            // 合并所有数据并返回
        }
    }
}

现有方案的核心问题 #

这种方案的最大问题在于处理器返回的是字符串，扩展性严重受限。比如我希望为每种返回类型生成JSON Schema，这就要求处理器在保留泛型特性的同时，能明确指定具体的返回类型。

设想的泛型改进方案 #

我尝试设计了带返回类型的泛型接口，代码如下：

public interface IProcessorWithType<TReturn> {
    public TReturn GetData();
}

public class OrderResult { }

public class OrdersDataProcessorWithType : IProcessorWithType<OrderResult> {
    public OrderResult GetData() {
        // 从数据源请求数据
        var data = new OrderResult { };

        return data;
    }
}

public class UsersResult { }
public class UsersDataProcessorWithType : IProcessorWithType<UsersResult> {
    public UsersResult GetData() {
        // 从数据源请求数据
        var data = new UsersResult { };

        return data;
    }
}

遇到的困境：运行时动态解析依赖 #

我无法实现运行时的动态依赖解析，以下是我的最新尝试，但仍需要提前指定返回类型才能解析：

public class ResolveTest {
    private readonly IUnityContainer unity;

    public ResolveTest(IUnityContainer unity) {
        this.unity = unity;
    }
    public void Test() {
        var type = typeof(UsersResult);
        var processorType = typeof(IProcessorWithType<>).MakeGenericType(type);

        var registrations = unity.Registrations.Where(r => r.RegisteredType == processorType);

        foreach (var registration in registrations) {
            // 这段代码无法正常工作
            var processor = unity.Resolve(processorType, registration.Name) as IProcessorWithType;
        }
    }
}

请问有没有更好的解决方案？

内容的提问来源于stack exchange，提问作者Arturio