将通用类型参数传递给Func

Question

我的代码库中有几个函数，例如CallMyFunction 。 我想将它们重构为一个通用函数

enum MyEnum
{
    ValueA,
    ValueB,
    ValueC
}

static void MyFunction<T>()
{
    //...
}

static void CallMyFunction(MyEnum myEnum)
{
    switch (myEnum)
    {
        case MyEnum.ValueA:
            MyFunction<A>();
            break;
        case MyEnum.ValueB:
            MyFunction<B>();
            break;
        case MyEnum.ValueC:
            MyFunction<C>();
            break;                                                              
    }
}

我希望能够有类似的东西

//I would like to make it work for Func<T> too
static void GenericCall(MyEnum myEnum, Action<?????> myFunc) 
{
    switch (myEnum)
    {
        case MyEnum.ValueA:
            myFunc<A>();
            break;
        case MyEnum.ValueB:
            myFunc<B>();
            break;
        case MyEnum.ValueC:
            myFunc<C>();
            break;                                                              
    }
}

//And then call it like this
GenericCall(myEnum, MyFunction);
GenericCall(myEnum, AnotherFunction);

Answer 1

我只需要创建一个关于肌腱/动作对的字典

您的字典：

Dictionary<MyEnum,Action> actions = new Dictionary<MyEnum,Action>()
{
    {ValueA, ()=>{your code...}},
    {ValueB, ()=>{your code...}}
};

调用方法

static void CallMyFunction(MyEnum myEnum)
{
    actions[myEnum]();
}

Answer 2

在您的示例中，对MyFunction<>任何调用都没有参数 ，这意味着Action不需要通用参数。 同样，您不能更改为CallMyFunction<T>因为T取决于enum改变。

至于<A> ， <B>和<C> ，必须在每种case都指定它们，而不是将其作为Action泛型参数的一部分放入。 switch正在调用方法，而不是GenericCall的调用者。 这就是您要解决的关键点，它可以基于enum值动态选择<A> ， <B>和<C> 。

试图为myFunc CallMyFunction加上一个参数，实际上意味着调用者必须提供A ， B和C类型，这会否决switch的目的。 我想这不是您要尝试做的。

重构的一种方法是更改​​方法MyFunction<T>以将类型参数作为参数而不是泛型。 这将允许您执行以下操作；

enum MyEnum
{
    ValueA,
    ValueB,
    ValueC
}

static void MyFunction(Type type)
{
    //...
}

static void CallMyFunction(MyEnum myEnum)
{
    Type type;
    switch (myEnum)
    {
        case MyEnum.ValueA:
            type = typeof(A);
            break;
        case MyEnum.ValueB:
            type = typeof(B);
            break;
        case MyEnum.ValueC:
            type = typeof(C);
            break;                                                              
    }
    MyFunction(type);
}

但是，这并不能真正为您节省任何费用。

为了从中获得适当的价值，您可以创建一个自定义Attribute ，该Attribute采用Type的构造函数参数，并将该Attribute直接应用于enum 。 您可以将函数MyFunction修改为检查枚举中的Attribute ，并将正确的类型正确传递给MyFunction 。

也就是说，仅当enum值/类型较大（> 10）时，才值得这样做。 目前的结构相当简单，易于维护（如果是平凡的话）。

值得一提的是，您还可以使用反射来调用MyFunction<>并在运行时提供泛型参数，但是您仍然可以通过enum选择类型。 它将添加更多代码来维护而不是减少代码。