如何从对象的类型属性中动态设置泛型的T类型？

我之前做类似的动态泛型实例化需求时，刚好碰到过这种场景——手里只有Type对象，要对应到泛型类的参数上，核心思路就是靠反射来搞定，下面一步步给你拆解：

首先先对齐一下我们的基础代码（先把你提到的类补全，方便后续演示）：

// 你的Mapper类，保存类型属性
public class Mapper
{
    public string Key { get; set; }
    public Type RequestType { get; set; }
    public Type ResponseType { get; set; }

    public Mapper()
    {
        // 初始化示例类型
        RequestType = typeof(SomeType);
        ResponseType = typeof(SomeType2);
    }
}

// 你的泛型Handler类，要求T有无参构造函数
public class Handler<T> where T : new()
{
    public void HandleRequest(T request)
    {
        // 处理逻辑示例
        Console.WriteLine($"Handling request of type {typeof(T).Name}");
    }
}

// 示例实体类，满足无参构造
public class SomeType { }
public class SomeType2 { }

接下来就是关键的动态创建步骤：

1. 获取Handler的开放泛型类型 #

首先要拿到Handler<>的开放类型（也就是不带具体泛型参数的模板类型），用typeof(Handler<>)就能直接获取到。

2. 构造闭合的泛型类型 #

用Mapper里的RequestType（也就是你要作为T的目标类型），结合开放类型构造出具体的Handler<SomeType>这种闭合泛型类型。

3. 反射创建实例 #

因为Handler要求T有无参构造，所以创建前要先校验目标类型是否满足这个约束，然后用反射API完成实例化。

直接上完整的动态创建代码：

public static object CreateHandlerFromMapper(Mapper mapper)
{
    // 1. 获取Handler的开放泛型类型
    Type openHandlerType = typeof(Handler<>);
    
    // 2. 构造闭合泛型类型：Handler<T>，这里T是mapper.RequestType
    Type closedHandlerType = openHandlerType.MakeGenericType(mapper.RequestType);
    
    // 3. 检查T是否满足无参构造约束（因为Handler<T>有这个要求）
    if (mapper.RequestType.GetConstructor(Type.EmptyTypes) == null)
    {
        throw new InvalidOperationException($"类型 {mapper.RequestType.Name} 没有无参构造函数，无法创建对应的Handler实例");
    }
    
    // 4. 创建实例
    return Activator.CreateInstance(closedHandlerType);
}

优化：统一处理的非泛型接口 #

如果想避免每次都强转object，可以给Handler定义一个非泛型接口，方便统一调用逻辑：

// 定义非泛型接口，统一处理入口
public interface IHandler
{
    void Handle(object request);
}

// 修改Handler<T>实现这个接口
public class Handler<T> : IHandler where T : new()
{
    public void HandleRequest(T request)
    {
        Console.WriteLine($"Handling request of type {typeof(T).Name}");
    }

    // 实现非泛型接口，做类型转换适配
    public void Handle(object request)
    {
        if (request is T typedRequest)
        {
            HandleRequest(typedRequest);
        }
        else
        {
            throw new ArgumentException($"请求类型不匹配，预期 {typeof(T).Name}");
        }
    }
}

这样调用的时候就可以直接转成IHandler，不用关心具体的泛型参数：

var mapper = new Mapper();
var handler = (IHandler)CreateHandlerFromMapper(mapper);
handler.Handle(new SomeType()); // 正常执行处理逻辑

注意事项 #

• 一定要提前校验T类型的无参构造函数，不然实例化时会抛出异常
• 如果你的Handler有带参数的构造函数，就要用Type.GetConstructor指定参数类型，再通过ConstructorInfo.Invoke来实例化
• 反射操作性能略低于直接实例化，高频调用场景可以考虑缓存创建好的闭合类型或实例

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