mudar com comportamento estranho var / null

Dado o seguinte código:

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

Por que a instrução switch está ativada case var o?

É meu entendimento que case string snão corresponde a quando s == nullporque (efetivamente) (null as string) != nullavalia como falso. O IntelliSense no VS Code me diz que também oé string. Alguma ideia?

Semelhante a: caso de switch C # 7 com verificações nulas

Dentro de uma switchinstrução de correspondência de padrões usando um casepara um tipo explícito está perguntando se o valor em questão é daquele tipo específico ou um tipo derivado. É o equivalente exato deis

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

O valor nullnão tem um tipo e, portanto, não satisfaz nenhuma das condições acima. O tipo estático de someStringnão entra em jogo em nenhum dos exemplos.

O vartipo embora na correspondência de padrões atua como um curinga e corresponderá a qualquer valor incluindo null.

O defaultcaso aqui é um código morto. O case var ocorresponderá a qualquer valor, nulo ou não nulo. Um caso não padrão sempre vence o padrão, portanto default, nunca será atingido. Se você olhar para o IL, verá que nem mesmo é emitido.

À primeira vista, pode parecer estranho que isso compile sem qualquer aviso (definitivamente me confundiu). Mas isso é compatível com o comportamento do C # que remonta a 1.0. O compilador permite defaultcasos mesmo quando pode provar trivialmente que nunca será atingido. Considere como exemplo o seguinte:

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

Aqui defaultnunca será atingido (mesmo boolque tenha um valor que não seja 1 ou 0). No entanto, o C # permite isso desde 1.0 sem aviso. A correspondência de padrões está apenas se alinhando com esse comportamento aqui.

Estou juntando vários comentários do Twitter aqui - isso é realmente novo para mim, e espero que jaredpar me dê uma resposta mais abrangente, mas; versão curta como eu entendo:

case string s:

é interpretado como if(someString is string) { s = (string)someString; ...ou if((s = (someString as string)) != null) { ... }- qualquer um dos quais envolve um nullteste - que falhou no seu caso; inversamente:

case var o:

onde o compilador resolve ocomo stringestá simplesmente o = (string)someString; ...- nenhum nullteste, apesar do fato de que parece semelhante na superfície, apenas com o compilador fornecendo o tipo.

finalmente:

default:

aqui não pode ser alcançado , porque o caso acima abrange tudo. Isso pode ser um bug do compilador, pois ele não emitiu um aviso de código inacessível.

Concordo que isso é muito sutil, matizado e confuso. Mas aparentemente o case var ocenário tem usos com propagação nula ( o?.Length ?? 0etc). Concordo que é estranho que isso funcione de maneira muito diferente entre var oe string s, mas é o que o compilador faz atualmente.

É porque case <Type>corresponde ao tipo dinâmico (tempo de execução), não ao tipo estático (tempo de compilação). nullnão tem um tipo dinâmico, por isso não pode ser comparado string. varé apenas o retrocesso.

(Postando porque gosto de respostas curtas.)