mit var / null seltsames Verhalten wechseln

Gegeben den folgenden Code:

string someString = null;
switch (someString)
{
    case string s:
        Console.WriteLine("string s");
        break;
    case var o:
        Console.WriteLine("var o");
        break;
    default:
        Console.WriteLine("default");
        break;
}

Warum stimmt die switch-Anweisung überein case var o?

Es ist mein Verständnis, case string sdas nicht übereinstimmt, wenn, s == nullweil (effektiv) (null as string) != nullals falsch bewertet. IntelliSense auf VS Code sagt mir, dass dies auch ein oist string. Irgendwelche Gedanken?

Ähnlich wie: C # 7-Schalterfall mit Nullprüfungen

In einer Mustervergleichsanweisung switchmit a casefür einen expliziten Typ wird gefragt, ob der betreffende Wert von diesem bestimmten Typ oder einem abgeleiteten Typ ist. Es ist das genaue Äquivalent vonis

switch (someString) {
  case string s:
}
if (someString is string) 

Der Wert nullhat keinen Typ und erfüllt daher keine der oben genannten Bedingungen. Der statische Typ von someStringkommt in beiden Beispielen nicht ins Spiel.

Der varTyp beim Mustervergleich fungiert jedoch als Platzhalter und entspricht jedem Wert, einschließlich null.

Der defaultFall hier ist toter Code. Das entspricht case var ojedem Wert, null oder nicht null. Ein nicht standardmäßiger Fall gewinnt immer über einen standardmäßigen Fall und defaultwird daher niemals getroffen. Wenn Sie sich die IL ansehen, werden Sie sehen, dass sie nicht einmal ausgestrahlt wird.

Auf den ersten Blick mag es seltsam erscheinen, dass dies ohne Vorwarnung kompiliert wird (hat mich definitiv abgeworfen). Dies stimmt jedoch mit dem C # -Verhalten überein, das auf 1.0 zurückgeht. Der Compiler erlaubt defaultFälle, auch wenn er trivial beweisen kann, dass er niemals getroffen wird. Betrachten Sie als Beispiel Folgendes:

bool b = ...;
switch (b) {
  case true: ...
  case false: ...
  default: ...
}

Hier defaultwird niemals getroffen (auch boolwenn der Wert nicht 1 oder 0 ist). C # hat dies jedoch seit 1.0 ohne Vorwarnung zugelassen. Der Mustervergleich entspricht hier nur diesem Verhalten.

Ich stelle hier mehrere Twitter-Kommentare zusammen - das ist eigentlich neu für mich und ich hoffe, dass Jaredpar mit einer umfassenderen Antwort einspringt, aber; Kurzfassung, wie ich sie verstehe:

case string s:

wird interpretiert als if(someString is string) { s = (string)someString; ...oder if((s = (someString as string)) != null) { ... }- was einen nullTest beinhaltet - was in Ihrem Fall fehlgeschlagen ist; umgekehrt:

case var o:

wo die Compiler Entschlüsse oals stringeinfach ist o = (string)someString; ...- kein nullTest, trotz der Tatsache , dass es auf der Oberfläche ähnlich sieht, nur mit dem Compiler die Art zu schaffen.

endlich:

default:

hier kann nicht erreicht werden , weil der obige Fall alles fängt. Dies kann ein Compiler-Fehler sein, da keine nicht erreichbare Code-Warnung ausgegeben wurde.

Ich stimme zu, dass dies sehr subtil und nuanciert und verwirrend ist. Aber anscheinend hat das case var oSzenario Verwendung mit Null-Weitergabe ( o?.Length ?? 0usw.). Ich bin damit einverstanden , dass es seltsam ist , dass das funktioniert so sehr unterschiedlich zwischen var ound string s, aber es ist das, was der Compiler zur Zeit der Fall ist.

Dies liegt daran, dass case <Type>Übereinstimmungen mit dem dynamischen Typ (Laufzeit) und nicht mit dem statischen Typ (Kompilierungszeit) übereinstimmen. nullhat keinen dynamischen Typ, kann also nicht mithalten string. varist nur der Fallback.

(Posting, weil ich kurze Antworten mag.)