Ilustração mostrando o logotipo C# acima de um laptop
Shutterstock.com/PHOTOGRIN

Uma prévia dos recursos selecionados a serem incluídos na versão C# 11 deste ano já está disponível como parte da Atualização 1 do Visual Studio 2022. A adição mais controversa é o suporte integrado à verificação de nulos de parâmetro. Isso usa geração de código para eliminar comparações manuais com null.

Neste artigo, exploraremos o estado atual do recurso, as críticas feitas a ele e como ele pode mudar antes do lançamento final. A sintaxe e os comportamentos descritos aqui se aplicam à visualização atual do C# 11 (março de 2022) e podem mudar consideravelmente antes do lançamento.

O que é verificação de nulo de parâmetro?

Primeiro vamos esclarecer do que estamos falando. Parâmetros C# sem tipos de referência anuláveis ​​aceitam null como um valor independentemente do seu tipo real:

private string hello(string name) {
 return "Hello " + name;
 }
   // This works
 hello(null);

Este comportamento é muitas vezes indesejável. No exemplo acima, passando null produziria uma saída absurda. Para superar esse problema, é comum os desenvolvedores adicionarem seus próprios null-verifica no topo dos métodos:

private string hello(string name) {
   if (name is null) {
 throw new ArgumentNullException(nameof(name));
 }
   return "Hello " + name;
   }
   // ArgumentNullException
 hello(null);

Isso pode criar muito código clichê quando um método tem vários parâmetros não anuláveis.

Sintaxe de verificação de nulo de parâmetro em C# 11

O C# 11 permite condensar o exemplo acima no seguinte código:

private string hello(string name!!) {
 return "Hello " + name;
 }
   // ArgumentNullException
 hello(null);

O especial !! sintaxe após o nome do parâmetro tem o mesmo efeito que um manual if (... is null) / throw new ArgumentNullException(...) bloquear. A ArgumentNullException instância será lançada se você passar null para um parâmetro que usa a sintaxe.

Quando vários parâmetros são marcados como não anuláveis, as verificações são executadas na ordem do parâmetro conforme escrito. A exceção lançada fará referência ao primeiro parâmetro não anulável a receber null na invocação.

A sintaxe pode ser usada com a maioria dos tipos de parâmetros, incluindo aqueles em async métodos, iteradores e lambdas. Não funciona com parâmetros de métodos abstratos, extern e delegados parâmetros e métodos de interface que não são um método de interface padrão (DIM).

Como funciona?

A nova sintaxe é baseada na geração de código do compilador. O compilador cria o familiar if (... is null) / throw new ArgumentNullException(...) código conforme ele processa seus arquivos de origem.

O recurso não está adicionando nada aos recursos de linguagem do C#. Ele está apenas escrevendo código de usuário comum para você, oferecendo uma sintaxe concisa que reduz as seções de origem repetitivas.

O código gerado é posicionado na parte superior de cada método afetado. Se o método for um construtor, o código será executado antes das inicializações dos campos da classe e de qualquer chamada ao this e base construtores. Essa é a única diferença prática em comparação com as expressões de verificação nula criadas manualmente.

Por que é polêmico?

Os críticos da proposta estão preocupados com a sintaxe (!! comunica mal seu significado e efeito), sua presença no nome do parâmetro em vez do tipo e se a geração de código clichê está dentro do escopo do projeto de linguagem C#. Há também debates sobre as interações da verificação nula com tipos de referência anuláveis.

Vamos desfazer alguns desses argumentos e suas implicações.

!! Existe no nome do parâmetro, não no tipo

Escrevendo string param!! parece antinatural porque você aparentemente está imbuindo o nome do parâmetro com comportamento extra, em vez do tipo. No entanto, isso é totalmente consistente com o que realmente está acontecendo.

A verificação de tipo é uma atividade no nível do compilador; a verificação nula do parâmetro gera tempo de execução código que verifica o valor do parâmetro. Portanto, faz sentido que a sintaxe tenha como alvo o parâmetro em vez de sua tipo.

Os nomes dos parâmetros não devem revelar detalhes de implementação

Outra reclamação é que param!! comunica informações sobre a implementação do método por meio de sua declaração. A sintaxe não afeta a assinatura do método, mas revela aspectos internos. Isso é insatisfatório para muitos desenvolvedores.

Uma maneira flutuante de resolver o problema seria fornecer o comportamento de verificação de nulo do parâmetro como um atributo. No entanto, não é para isso que servem os atributos – eles são metadados simples, enquanto as verificações nulas geram código de tempo de execução. Há também precedentes para o comportamento de !! em outros componentes de declaração de método: pegue asyncque revela que seu destino é assíncrono e conecta um modelo de execução apropriado para você.

Compatibilidade com tipos de referência nulos

As verificações de parâmetro nulo e os tipos de referência nula (NRTs) são compatíveis entre si. No entanto, você verá novos avisos do compilador se combinar !! com um tipo anulável:

private string hello(string? name!!) {
 // ...
 }

Neste exemplo o string? tipo permite explicitamente null enquanto name!! rejeita-o em tempo de execução. O compilador detecta essa condição contraditória e emite um aviso:

CS8995 Nullable type 'string?' is null-checked and will throw if null.

Se os dois mecanismos conceitualmente compatível é um problema diferente. Os tipos de referência anuláveis ​​impõem um valor que não pode ser null em tempo de compilação. As verificações nulas de parâmetro lançam uma exceção quando um valor é null em tempo de execução. Em um cenário ideal, apenas o primeiro seria necessário – todos os métodos usariam NRTs para indicar se eles podem aceitar null e a execução seria totalmente tratada pelo compilador.

Infelizmente, o cenário C# não é ideal. Os tipos de referência anuláveis ​​são um recurso opcional que não foi adotado universalmente. Não é realista esperar que todo o código existente acumulado ao longo dos 20 anos da linguagem C# dê suporte a NRTs. As verificações nulas de parâmetro são uma maneira pragmática de conectar um novo código que usa predominantemente NRTs com bibliotecas mais antigas que podem retornar null em tempo de execução. Eles fazem sentido onde seus métodos podem ser entregues null – então um NRT não pode ser usado – por código que não adotou a abordagem moderna.

É um erro se aproximar param!! como forma de sinalizar que o parâmetro não deve ser passado null – esse é o requisito que string? serve para. A presença de !! é conhecido apenas pelo compilador. Está lá para levantar um ArgumentNullException em seu nome.

A geração de código pode ser uma má ideia

Existem algumas exibições em que a geração automática de código para executar essa função pode ser mais problemática do que vale a pena. Embora possa remover muitos clichês, também pode causar comportamentos inesperados e dificultar o raciocínio sobre o programa.

Os desenvolvedores precisam entender que ArgumentNullException instâncias podem ser lançadas em qualquer lugar !! é usado. A exceção é inflexível e não pode ser alterada, mesmo em situações como membros de instância onde um NullReferenceException pode ser mais apropriado. Isso levou alguns comentaristas a sugerir que as verificações nulas de parâmetro em sua forma atual não deveriam se tornar parte do C#.

Não há uma resposta direta para este problema. Evidentemente, a equipe de desenvolvimento C# decidiu que a geração de código terá um benefício líquido positivo na comunidade, economizando tempo e reduzindo a repetitividade. No entanto, deve-se reconhecer que verificações nulas resultam em código de tamanho único sendo adicionado ao seu projeto, criando a possibilidade de problemas se esse tamanho for posteriormente provado incorreto.

Resumo

Dois personagens criaram uma discussão que ainda está se desenrolando: do jeito que está, param!! está chegando ao C# como uma forma de gerar throw ArgumentNullException(...) para você. Apesar de seu potencial para reduzir o código clichê – mais de 20.000 verificações nulas explícitas foram removidas do .NET Runtime usando a sintaxe – ainda existem várias dúvidas e preocupações persistentes.

Dissecamos os mais proeminentes acima e vimos que a maioria das reclamações é infundada e baseada em mal-entendidos. Indiscutivelmente a maior crítica envolve a própria sintaxe, com !! visto como opaco, difícil de descobrir e inacessível aos recém-chegados. Existem várias propostas para substituí-lo por algo mais óbvio; string param notnull está ganhando atenção considerável, então a forma final pode parecer diferente quando o C# 11 chegar.

Você pode dar sua opinião sobre a proposta contribuindo para o tópico de discussão no GitHub. Se você quiser experimentar a visualização atual por conta própria, precisará do Visual Studio 17.1 (Atualização 1 de 2022) e do .NET SDK 6.0.200. Você então precisará mudar LangVersion para preview dentro de seu .csproj para habilitar o suporte ao C# 11.


Fonte Adicione ao Google Notícias