Pass generic type parameter to Func

Question

I have a couple of function like CallMyFunction in my codebase. I would like to refactor them into one generic function

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 be able to have something like

//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);

score 2 · Answer 1 · answered Nov 01 '17 at 20:28

2

I would simply create a dictionary of myenum/action pairs

Your dictionary:

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

calling a method

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

answered Nov 01 '17 at 20:28

Eser

12,346
1
22
32

2

According to the following: https://stackoverflow.com/questions/11617091/in-a-switch-vs-dictionary-for-a-value-of-func-which-is-faster-and-why, this may impact performance. – Joel Bourbonnais Nov 01 '17 at 20:30
1

@KOTIX I agree if you have a millions of cases for a switch. – Eser Nov 01 '17 at 20:31
1

@KOTIX, you'd also have the performance overhead of the lambda. It's a fairly clean approach though if you're ok with the performance overhead. – DiskJunky Nov 01 '17 at 20:31
@DiskJunky What is overhead of lamba other than calling a function in this case? – L.B Nov 01 '17 at 20:32
@L.B the answer to that would take longer than I could reasonably put into a comment :) TL;DR version is that .NET has to do some wrangling to work out how to call the lambda and the JIT isn't a fan if performance is critical. Explicit methods are easier for it to deal with – DiskJunky Nov 01 '17 at 20:34
@L.B, it's a big topic; https://stackoverflow.com/questions/672918/when-not-to-use-lambda-expressions. – DiskJunky Nov 01 '17 at 20:37
This doesn't answer the question. What I want to do is to only do one switch-case and then calling it by only passing my function. I edited the question to add examples of how I want to use it – Bruno Nov 01 '17 at 20:38
2

@DiskJunky A lamda query is just function call determined at compile time. Not a big topic. `x=>x==1` is just equals to `delegate(int i){ return x==1;}` – L.B Nov 01 '17 at 20:38
@L.B that doesn't quite sit with my (limited) understanding of how the JIT deals with lambdas but I'll bow to your greater expertise on this. Consider it moot. – DiskJunky Nov 01 '17 at 20:43
@Bruno I think Eser's answer does exactly what you want to do and is better approach than yours – L.B Nov 01 '17 at 20:45
@L.B not really, he's just converting a switch case to a dictionary. Which is basically less safe (no possible warning if I want to add a new value in your Enum). Also, you have to do a new dictionary every time you want to use the enum with another function, which is the same code duplication that I already have. – Bruno Nov 01 '17 at 20:53
@Bruno you have to pick the method to call *somehow*. Be it via `Dictionary` or `switch` or even `if` is moot. Your alternative is to call the appropriate method instead of where you're calling `MyFunction` as it is at present. If you don't want your decider to be the *caller* of `MyFunction` then the selection must be put inside it, regardless if which mechanism you choose. – DiskJunky Nov 01 '17 at 20:56
1

@Bruno Question is yours, use this post or not, but all of your arguments in previous comment are invalid (about safity, code duplicates etc. I think you didn't understand this answer enough) – L.B Nov 01 '17 at 20:56
I don't understand why my arguments are invalid, I just want to be able to remove some duplicated code and your answer doesn't solve the issue, since I would have to do one dictionary per function instead of a switch-case per function, which is basically the same thing – Bruno Nov 01 '17 at 21:04
@Bruno it *is* pretty much the same thing but what it does is allow for shorter code as you're writing one line for each call to `Add` rather than spelling out each `case` and `break` in a `switch`. How you select doesn't much matter as you have to select somehow, regardless of what approach is taken. This reduces the question to "what's the shortest way to select my function?" – DiskJunky Nov 01 '17 at 21:08
@DiskJunky I'm not trying to golf my function, I'm trying to avoid duplicate like I said 3 times – Bruno Nov 01 '17 at 21:10
@Bruno we're going by the example you've posted. `myFunc`, `myFunc` and `myFunc` are not the same things - no duplication. These are selected by `enum` meaning that *something* has to tie the `enum` to the `<>`. This can be a `swtich`, `Dictionary`, `Attribute`etc. but something has to spell it out. It can't be decided by the caller of `CallMyFunction` (and hence a generic), or there's no point at all in `CallMyFunction`. You're just putting the decision on the caller rather than in `CallMyFunction` itself. If you have a more explicit example, we can try to work with that – DiskJunky Nov 01 '17 at 21:13

DiskJunky · Answer 2 · 2017-11-01T20:26:07.070

In your example, there are no parameters for any calls to MyFunction<>, meaning there are no generic arguments required for Action. Likewise, you cannot change to CallMyFunction<T> as T changes depending on the enum.

As for <A>, <B> and <C>, these have to be specified in each case rather than put in as part of a generic argument to Action. The switch is calling the methods, not the caller of GenericCall. It's this key point that you're working around, to dynamically select <A>, <B> and <C> based on the enum value.

Trying to put an argument into CallMyFunction for myFunc effectively means the caller has to supply the types A, B and C which negates the purpose of the switch. This isn't what you're trying to do I think.

One way of refactoring would be to change the method MyFunction<T> to take the type parameter as a parameter rather than a generic. This would allow you to do the following;

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);
}

However this doesn't really save you anything.

To get proper value out of it, you could create a custom Attribute that took a constructor argument of Type and apply the Attribute directly to the enum. Your function MyFunction, could be modified to check for the Attribute on the enum and correctly pass the correct type to MyFunction.

That said, it'd only be worth it if you had a large (>10) enum values/types. The structure as it stands is fairly straight forward and easy (if mundane), to maintain.

It's worth mentioning that you could also use reflection to call MyFunction<> and supply the generic argument at runtime but you'd still be left with picking out the type by enum. It would add more code to maintain rather than reduce it.

Pass generic type parameter to Func

2 Answers2