无具体对象时如何传递带init setter的接口泛型创建方法

我刚好之前做过类似的动态接口实现项目，对你遇到的这个痛点太熟悉了——动态生成的接口实现类型只存在于运行时，编译时根本没法直接引用，导致你没法把针对该类型的泛型创建方法（比如CreateFoo<T>）直接转成强类型委托传出函数对吧？下面给你几个亲测可行的解决方案，按实用性排序：

方案1：用非泛型委托包装+接口显式转换 #

这是最直接的思路：既然编译时不知道具体实现类型，我们就把创建逻辑包装成Func<object>类型的委托，返回的实例再显式转换为目标接口。这样既能轻松传出函数，调用方也只需要关心接口类型，完全不用管底层的动态实现细节。

举个简化的代码例子：

// 假设你在动态生成类型的函数内部
Func<object> CreateInstanceDelegate = () => {
    // 这里执行你用Reflection.Emit创建实例、设置init setter的逻辑
    // 比如通过反射调用你的泛型CreateFoo方法
    var createMethod = typeof(YourGeneratorClass).GetMethod("CreateFoo")
        .MakeGenericMethod(yourTargetInterface);
    return createMethod.Invoke(null, null);
};

// 直接把这个委托传出函数就行
return CreateInstanceDelegate;

调用方用起来也很简单：

var createInstance = GetYourCreateDelegate();
IMyInterface myInstance = (IMyInterface)createInstance();
// 此时myInstance已经是动态实现的实例，init setter也已经设置完毕

方案2：用表达式树构建强类型委托 #

如果你想要更接近强类型的体验，完全可以用System.Linq.Expressions来替代直接反射调用泛型方法。表达式树能在运行时构建出Func<TInterface>这样的强类型委托，调用方拿到后直接调用就能得到接口实例，连显式转换都省了。

大致的实现步骤是这样：

1. 用Reflection.Emit生成接口的实现类型后，拿到它的构造函数。
2. 构建表达式树：先调用构造函数创建实例，再通过Expression.Assign设置init setter（注意init的限制只在编译时，运行时实例是可变的，所以完全可以这么做）。
3. 把表达式树编译成Func<TInterface>委托，直接传出函数。

代码片段参考：

// 假设dynamicType是你生成的接口实现类型，yourTargetInterface是目标接口
var ctor = dynamicType.GetConstructor(Type.EmptyTypes);
var instanceExpr = Expression.New(ctor);

// 处理init setter：比如接口有个Init属性叫Name
var nameProperty = yourTargetInterface.GetProperty("Name");
var assignExpr = Expression.Assign(
    Expression.Property(instanceExpr, nameProperty),
    Expression.Constant("Test Value")
);

// 构建块表达式：先创建实例，再赋值，最后返回实例
var blockExpr = Expression.Block(
    instanceExpr,
    assignExpr,
    instanceExpr
);

// 编译成强类型委托
var createDelegate = Expression.Lambda<Func<IMyInterface>>(blockExpr).Compile();

// 把这个强类型委托传出
return createDelegate;

调用方拿到createDelegate后直接调用就行：

IMyInterface myInstance = createDelegate();

这个方案兼顾了灵活性和强类型体验，性能也不错，我个人最推荐这个。

方案3：泛型方法反射调用+缓存封装 #

如果你坚持要保留原来的泛型创建方法（比如CreateFoo<T>），可以把这个方法的反射调用封装成一个带缓存的静态工厂类，通过接口类型作为参数来获取对应的创建委托。这样能避免重复反射，性能更优。

示例代码：

public static class DynamicInstanceFactory
{
    private static readonly Dictionary<Type, Delegate> _factoryCache = new();

    public static Func<T> GetFactory<T>() where T : class
    {
        var interfaceType = typeof(T);
        if (_factoryCache.TryGetValue(interfaceType, out var del))
        {
            return (Func<T>)del;
        }

        // 调用你的Reflection.Emit逻辑生成实现类型
        var dynamicType = GenerateInterfaceImplementation(interfaceType);
        // 拿到泛型创建方法的反射实例
        var createMethod = typeof(DynamicInstanceFactory)
            .GetMethod(nameof(CreateAndInitInstance), BindingFlags.NonPublic | BindingFlags.Static)
            .MakeGenericMethod(dynamicType);
        
        // 创建强类型委托并存入缓存
        var factory = (Func<T>)Delegate.CreateDelegate(typeof(Func<T>), createMethod);
        _factoryCache[interfaceType] = factory;
        return factory;
    }

    private static T CreateAndInitInstance<T>() where T : new()
    {
        var instance = new T();
        // 这里处理init setter的赋值逻辑，比如通过反射设置属性
        return instance;
    }
}

调用方使用时只需要一行：

var factory = DynamicInstanceFactory.GetFactory<IMyInterface>();
IMyInterface myInstance = factory();

关于闭包类的替代思路 #

你提到如果支持函数内嵌套闭包类就能解决，确实C#目前不允许在函数内部定义泛型类并引用外部动态类型，但上面的几个方案其实都是绕开了这个限制——通过委托、表达式树或者反射封装，把动态生成类型的创建逻辑包装成编译时可见的类型（比如Func<object>或Func<TInterface>），从而实现传出函数的目的。

总结一下：追求简单选方案1，想要强类型体验选方案2，看重性能和缓存选方案3，这三个方案都能完美解决你的问题。

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