C# 7 switch/case using "when" the way it's not meant to be used [closed] - switch-statement

Question

Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 5 years ago.
Improve this question
I've started using this format of switch statement. It works, but is there a purist view that the following is bad practice? On the plus side it can be a lot more readable than deeply nested if statements. On the downside, I don't think it is meant to be used like this:
int hour = DateTime.Now.Hour;
string timeWord;
switch ("ignore")
{
case string x when hour < 12:
timeWord = "morning";
break;
case string x when hour < 18:
timeWord = "afternoon";
break;
case string x when hour < 24:
timeWord = "evening";
break;
default:
throw new LogicException("Another fine mess you got us into");
}
Console.WriteLine("Good {timeWord}");
In terms of default I prefer defensive programming. I don't like using defaults as a catch-all. Impossible thing happen with amazing regularity. (ref: HHGTTG) The real question though is the (mis/ab)use of case.
EDIT UPDATE + Further update as I screwed up a cut and paste
It was suggested I post an example I has put in a comment. Here is a different one. There is an if-then example followed by a case. In no way are they meant to be the same, just to show what I meant about the clarity of nested ifs.
public class example
{
static Random rnd = new Random();
bool B1, B2, B3, B4, B5;
static bool GetBool() { return rnd.Next(1) == 0 ? false : true; }
bool Accept() { return GetBool(); }
bool Decline() { return GetBool(); }
List<bool?> nullBools = new List<bool?> { false, true, null };
bool? Other() { return nullBools[rnd.Next(2)]; }
void MaybeException() { }
public example()
{
// I don't think it is difficult to miss the holes in this logic
B1 = GetBool(); B2 = GetBool(); B3 = GetBool(); B4 = GetBool();
if (B1 && B2)
{
if (B3)
if (B4 & B5)
if (!Accept() & !Decline())
Other();
else
Decline();
else
if (B4 & !B5)
if (B1)
Decline();
else
Accept();
else
MaybeException();
}
else
{
if (!B1 && B2)
if (B5 & B4)
if (!Accept() && Other() != null)
Decline();
else
{
if (!Other() == null)
if (!Accept())
Decline();
else
Decline();
}
else
{
if (B4 && !B5)
Accept();
else
if (Other() == null)
if (!Accept())
Decline();
Decline();
}
}
// As opposed to
switch ("IGNORE")
{
case string B_0234 when !B1 && !B2 && B3 && B4:
case string B_1200 when B1 && B2 && !B3 && !B4:
case string B_1204 when B1 && B2 && !B3 && B4:
case string B_1234 when B1 && B2 && B3 && B4:
if (Other() == null)
Accept();
break;
case string B_0004 when !B1 && !B2 && !B3 && B4:
case string B_0134 when B1 && !B2 && B3 && B4:
case string B_1000 when B1 && !B2 && !B3 && !B4:
case string B_1030 when B1 && !B2 && B3 && !B4:
case string B_1203 when B1 && B2 && B3 && !B4:
case string B_1004 when B1 && !B2 && !B3 && B4: // Compile error duplicate
if (Other() == null)
if (!Accept())
Decline();
case string B_0230 when !B1 && B2 && B3 && !B4:
case string B_1201 when B1 && B2 && !B3 && B4:
case string B_1230 when B1 && B2 && B3 && !B4:
MaybeException();
break;
//case string B_0101 when !B1 && B2 && !B3 && B4:
//case string B_0000 when !B1 && !B2 && !B3 && !B4:
default:
throw new Exception("Whoops missed the two above impossible??");
}
}
}

Answer 1

I personally, wouldn't use such a construct - it is confusing, in particularly given that the object your are supposedly switching on isn't involved in the switching.
In your particular example, switching on hour would be much more natural.
A sequence of if statements (with returns) would read more naturally to me.
Alternatively, a dictionary, mapping hour with the return string could work well.

Answer 2

Compare it to the if-else structure, which has always been available:
if (hour < 12)
{
timeWord = "morning";
}
else if (hour < 18)
{
timeWord = "afternoon";
}
else if (hour < 24)
{
timeWord = "evening";
}
else
{
throw new LogicException("Another fine mess you got us into");
}
The latter code has pretty much the same structure, allows extending the conditions, and supports the last catch-all else part.
It doesn't have the "ignore" part, which might be confusing at first:
What exactly is being ignored here?
... Oh, it's the string "ignore" itself!
So what's the advantages of the case code structure? I could think of these:
case makes it clear that you want to check various values of some "main" variable, which may be modified by other variables. While if-else has pretty generic conditions.
If you are obliged to put braces {} around if-else code clauses, the switch code may become shorter
These advantages don't look strong to me.