C# 以相当简洁的方式向委托传递类构造函数的参数列表

Question

在 C# 中，我能否以相当简洁的方式向委托传递类构造函数的参数列表？

我知道这是非常特殊的情况，可能看起来有点奇怪，也不是工厂模式。如果它有助于将其视为挑战。这个问题的正确答案可能是不可能。

Func<MyClassConstructionArgsType, MyClass> make_MyClass =
    args => {return new MyClass(args);};

var n = make_MyClass(comma separated arguments);

我还需要不要有参数描述的副本，例如以下不是解决方案：

Func<int, string, MyClass> make_MyClass =
    (a, b) => {return new MyClass(a, b);};

或者，出于同样的原因：

Class Args
{
    ...
}

Func<Args, MyClass> make_MyClass =
    a => {return new MyClass(a);};

var n = make_MyClass(Args(args));

Dito 是这种情况：

var n = make_MyClass<MyClass>(comma separated arguments);

Object[]{逗号分隔参数}方法很好，除了还需要支持可选参数。

这个问题是根据 Anastasiosyal 对以下问题的回答创建的：c# class reference as opposed to instance reference

Josh 第一个答案似乎在 C# 中尽可能接近。

Answer 1

我仍然不是 100% 清楚您在这里寻找什么，但我会尝试一下。

我假设您要创建一个调用类的构造函数的委托，并返回该类的新实例。这样做的简单方法是：

var makeX = new Func<String, Integer, X>((s,i)=>new X(s,i));

// To use it
var myX = makeX("Foo", 5);

我不确定为什么在您的用例中这不是“可接受的”。如果您能指出这种方法的具体技术或语法问题，我会尽力解决。

编辑：

假设可以接受预定义自己的委托：

delegate X makeX(String s, Integer i);

那么你可以这样做：

var myMakeX = new makeX((s,i)=>new X(s,i));

// To use it
var myX = myMakeX("Foo", 5);

但我怀疑这是你能得到的最短的时间。现在，如果您提前知道，例如，所有时间都想将“Foo”指定为 s 的值，那么您可以创建另一个短路委托（使用称为 @987654321 的技术） @):

var myCurryMaker = new Func<String, Func<Integer, X>>(s => return new Func<Integer, X>(i => new X(s, i)));
var myCurriedX = myCurryMaker("Foo");

// To use it
var myX = myCurriedX(5);

Answer 2

并非没有某种形式的反思。

您可以创建一个使用 Activator 的委托：

Func<Object[], MyClass> makeClass =
   args => (MyClass) Activator.CreateInstance(typeof (MyClass), args);

makeClass(new object[] {"String", 32});

但这是尽可能接近使用委托的方式。但是，如果你创建一个静态帮助器，你可以让它看起来更漂亮：

public static T BuildType<T>(params Object[] args) {
   return (T) Activator.CreateInstance(typeof (T), args);
}

BuildType<MyClass>("String", 32);

再一次，如果没有反思，我不确定你是否能真正实现你想要的。

Answer 3

下面的一些事情怎么样：

public delegate object VariableParamFactoryFunc(params object[] constructorParams);

public class Factory
{
    private Dictionary<Type, VariableParamFactoryFunc> _registeredTypes = new Dictionary<Type, VariableParamFactoryFunc>();

    public void RegisterType<T>(VariableParamFactoryFunc factoryFunc)
    {
        _registeredTypes.Add(typeof(T), factoryFunc);
    }

    public T Resolve<T>(params object resolutionParams)
    {
        VariableParamFactoryFunc factoryFunc;
        if (_registeredTypes.TryGetValue(typeof(T), out factoryFunc))
        {
            return (T)factoryFunc();
        }
        else
        {
            return default(T);
        }
    }
}

然后您将通过首先注册工厂函数来使用它：（例如）

var factory = new Factory() // or you can turn it into a singleton, this is just for demonstration
factory.Register<IMyInterface>((a, b, c) => new ConcreteImplementation(a, b, c))
factory.Register<CustomClass>((a, b) => new CustomClass(a, b));

然后通过实际解析和使用这些工厂函数：

IMyInterface myInterface = factory.Resolve<IMyInterface>(1, "string", 2.412);
CustomClass customClass = factory.Resolve<CustomClass>("param1", 1234);

这应该允许您灵活地解析具有可变数量参数的构造函数，而不会支付 Activator.CreateInstance 或 Reflection 的性能损失，但是您会失去类型安全性，因为所有参数都将被强制转换为对象并且您需要将它们强制转换回到工厂函数中的正确类型

祝你好运！