C# 8.0 switch expression doesn't work with delegate types

[HazyFish]

The new switch expression introduced in C# 8.0 doesn't support delegate types.

var action = str switch
{
    "a" => () => MethodA(args),
    "b" => () => MethodB(args),
    "c" => () => MethodC(args),
};

var action = str switch
{
    "a" => MethodA,
    "b" => MethodB,
    "c" => MethodC
};

Using either lambda expression or method name will produce the following error:

No best type was found for the switch expression. (CS8506)

[Thaina]

It's not a problem of switch expression. Current C# compiler are not support type guessing of delegate in many situation. I think there was a proposal to let it always fallback to Action and Func but it not in C# 8.0

Actually

I think you need to made it into Action<> or Func<> explicitly like this

Action action = str switch {
    "a" => () => MethodA(args),
    "b" => () => MethodB(args),
    "c" => () => MethodC(args),
};

[HazyFish]

@Thaina
Unfortunately, assigning such a switch expression to an explicitly-typed variable doesn't work either.

[Thaina]

@HazyFish Yeah sorry, I don't have 8.0 compiler at hand so my suggestion is not really did tested

This also not working

However like so, this is not a problem of switch expression per se. This is the problem of C# compiler that cannot made a type out of pure lambda expression

But maybe the feature related to targeted type might solve this problem #2389 #2460 #2473

Around this time you might need to explicitly put a type on all cases

var action = str switch {
    "a" => new Action(() => MethodA(args)),
    "b" => new Action(() => MethodB(args)),
    "c" => new Action(() => MethodC(args)),
};

[LuisEduardoFrias]

yo lo hice de esta manera y me funcionado.

void action() { PropertyTables(tables); }

       `if (tables.Length > 0)
        {
            _ = CBView.SelectedItem switch
            {
                "Tablas" => () =>
                    {
                        
                    },
                "Vistas" => () =>
                    {
                        
                    },
                "Procedimientos" => () =>
                    {
                      
                    },
                "Triggers" => () =>
                    {
                       
                    },
                "Functions" => () =>
                    {
                      
                    },
                _ => (Action)action
            };`

[HazyFish]

Yeah, you are right.

[theunrepentantgeek]

SharpLab.io is a good place to try these things out ... this works, using the current master branch of Roslyn:

using System;
public class C {
    
    public void MethodA(string[] args) { }
    public void MethodB(string[] args) { }
    public void MethodC(string[] args) { }
    public void MethodD(string[] args) { }
    
    public void M(string s, string[] args) {
        Action action = s switch {
		    "a" => () => MethodA(args),
    		"b" => () => MethodB(args),
    		"c" => () => MethodC(args),
            _ => () => MethodD(args)
		};
    }
}

This is essentially what @Thaina suggested, but with a default case added at the end.

Try it out.

[333fred]

This has to do with target-typing. Method groups, by default, do not have a type and must be converted to a delegate type. This can be done through target-typing, but not all expressions allow target-typing through them. @HazyFish, the version of the compiler you're using does not support the changes made for #2389. Ternaries also do not currently support target-typing like this, but it has been proposed and championed here: #2460.

[DavidArno]

I think target-typing is only part of the story. It's possible to make the switch expression happy without target typing by explicitly casting one of the lambdas:

public void M(string s, string[] args) 
{
    var action = s switch {
        "a" => (Action)(() => MethodA(args)),
        "b" => () => MethodB(args),
        "c" => () => MethodC(args),
        _ => () => MethodD(args)
    };
}

But using target typing makes for a neater solution as no cast is needed inside the switch expression. It isn't limited to explicitly typed variables either, eg it can be used with expression bodied methods:

public Action M(string s, string[] args) 
    => s switch {
        "a" => () => MethodA(args),
        "b" => () => MethodB(args),
        "c" => () => MethodC(args),
        _ => () => MethodD(args)
    };

[333fred]

Yes. Switch expressions attempt to find a common type between all arms. If you cast on the first branch, we get a candidate type: Action. We then see whether the rest of the branches can be implicitly converted to this type, which they can, and thus the switch expression is typed as Action. If we can't find a common type (the case where there's no cast), then we fall back to trying to target-type the switch expression.

[DavidArno]

@333fred, and an excellent job you guys have done of all that. The ease with which a switch expression can be expressed and have its type inferred from the initial release of the feature really is impressive. 👍

[333fred]

Thank @gafter, he did all the real work :D