switch case with var for initialize variable in fall through case

[Thaina]

Sometimes the logic for switch condition could easily fall through with a very little changed in some variable. So I wish that we could append var at the case. And if we made a fall through case it then force all those set of cases must implement the same var

switch(SomeObj.SomeProperty.SomeEnumValue)
{
    case SomeEnum.A:
        DoSomeThing();
        break;

    // can be single tuple or any number of tuple element
    case SomeEnum.B var (resultString:"B",condition:true):
    case SomeEnum.C var (resultString:"C",condition:false):
    case SomeEnum.D when score > 50 var (resultString:"D",condition:true):
    case SomeEnum.D var (resultString:"D",condition:false):
    case SomeEnum.E: // ERROR : Use of unassigned local variable ; must adding same variable as above
        if(condition)
             DoSomeThing();

        DoSomeOtherThingWith(resultString);
        break;

    case SomeEnum.F: // a not-fall-through can be back to a normal case
    default:
        throw new NotImplementedException();
}

[Richiban]

Couldn't all such cases simply be handled by extracting a method or local function?

void HandleMethod(string resultString, bool condition)
{
    if(condition)
        DoSomeThing();

    DoSomeOtherThingWith(resultString);
}

switch(SomeObj.SomeProperty.SomeEnumValue)
{
    case SomeEnum.A:
        DoSomeThing();
        break;

    case SomeEnum.B: HandleMethod(resultString:"B", condition:true); break;
    case SomeEnum.C: HandleMethod(resultString:"C", condition:false); break;
    case SomeEnum.D when score > 50: HandleMethod (resultString:"D", condition:true); break;
    case SomeEnum.D: HandleMethod(resultString:"D", condition:false); break;
    case SomeEnum.E: HandleMethod(...); break;

    case SomeEnum.F: // a not-fall-through can be back to a normal case
    default:
        throw new NotImplementedException();
}

[Thaina]

@Richiban Sure, Like a switch expression that we could just extract it as local function. Or is var that could extract to be bool LocalFunction(out SomeType obj). Most of syntax we added lately could simply made to be local function. Why not?

[Richiban]

In the case of is var the function that would need to be introduced would literally do nothing; it would be plugging a gap in the syntax. In the case of your example though, I actually think that introducing a function is the clearer choice.

Also, the introduction of a variable in your switch statement conflicts with syntax constraints from other parts of C#, where a variable cannot be multiply declared in different code branches to then be available outside that branch. For example, the following is not legal:

if(someCondition)
{
	var x = 4;
}
else 
{
	var x = 5;
}

Console.WriteLine($"x = {x}");

[Thaina]

@Richiban To check for condition and return new variable is already did something. And it could be a function instead of specific syntax

if(SomeObject.SomeProperty.SomeField is var x)
    DoSomething(x);

// is functionally equivalence to

bool TryGet(out SomeType result)
{
    result = SomeObject.SomeProperty.SomeField;
    return result != null; 
}

if(TryGet(out var x))
    DoSomething(x);

So why we need it if anything could be made as local function? I think it should be obvious

And for second argument
No. I don't think a fall though case is difference branch. It is the same branch with || logic. So it should declare variable only once. The var tuple syntax just to make it set a value in sync but not really declare difference variable

It could be like this

switch(SomeObj.SomeProperty.SomeEnumValue)
{
    case SomeEnum.A:
        DoSomeThing();
        break;

    case SomeEnum.B var (resultString:"B",condition:true):
    case SomeEnum.C var (resultString:"C",condition:false):
    case SomeEnum.D when score > 50 var (resultString:"D",condition:true):
    case SomeEnum.D var (resultString:"D",condition:false):
        if(condition)
             DoSomeThing();

        DoSomeOtherThingWith(resultString);
        break;

    default:
        throw new NotImplementedException();
}

// is functionally equivalence to

var _cacheSwitch = SomeObj.SomeProperty.SomeEnumValue;
switch(_cacheSwitch)
{
    case SomeEnum.A:
        DoSomeThing();
        break;

    case SomeEnum.B:
    case SomeEnum.C:
    case SomeEnum.D when score > 50:
    case SomeEnum.D:
        var (resultString,condition) = default((string,bool));
        switch(_cacheSwitch)
        {
            case SomeEnum.B:
                (resultString,condition) = ("B",true);
                break;
            case SomeEnum.C:
                (resultString,condition) = ("C",false);
                break;
            case SomeEnum.D when score > 50:
                (resultString,condition) = ("D",true);
                break;
            case SomeEnum.D:
                (resultString,condition) = ("D",false);
                break;
        }

        if(condition)
             DoSomeThing();

        DoSomeOtherThingWith(resultString);
        break;

    default:
        throw new NotImplementedException();
}

[ronnygunawan]

This can be done using C# 7 pattern matching.

switch (SomeObj.SomeProperty.SomeEnumValue) {
    case SomeEnum.A:
        DoSomeThing();
        break;
    case SomeEnum.B when "B" is string resultString && true is bool condition:
    case SomeEnum.C when (resultString = "C") is string && (condition = false) is bool:
    case SomeEnum.D when score > 50 && (resultString = "D") is string && (condition = true) is l:
    case SomeEnum.D when (resultString = "D") is string && (condition = false) is bool:
    case SomeEnum.E: // ERROR : Use of unassigned local variable ; must adding same variable as above
        if (condition)
            DoSomeThing();
        DoSomeOtherThingWith(resultString);
        break;

    case SomeEnum.F: // a not-fall-through can be back to a normal case
    default:
        throw new NotImplementedException();
}