Tipos de referência anulados em C #Nullable reference types in C#

O objetivo deste recurso é:The goal of this feature is to:

  • Permitir que os desenvolvedores expressem se uma variável, parâmetro ou resultado de um tipo de referência se destina a ser nulo ou não.Allow developers to express whether a variable, parameter or result of a reference type is intended to be null or not.
  • Fornecer avisos quando tais variáveis, parâmetros e resultados não forem utilizados de acordo com essa intenção.Provide warnings when such variables, parameters and results are not used according to that intent.

Expressão de intençãoExpression of intent

O idioma já T? contém a sintaxe para tipos de valor.The language already contains the T? syntax for value types. É simples estender essa sintaxe aos tipos de referência.It is straightforward to extend this syntax to reference types.

Presume-se que a intenção de T um tipo de referência não adornada é que ele não seja nulo.It is assumed that the intent of an unadorned reference type T is for it to be non-null.

Verificação de referências anuladasChecking of nullable references

Uma análise de fluxo rastreia variáveis de referência anuladas.A flow analysis tracks nullable reference variables. Quando a análise considerar que eles não seriam nulos (por exemplo, após uma verificação ou uma atribuição), seu valor será considerado uma referência não nula.Where the analysis deems that they would not be null (e.g. after a check or an assignment), their value will be considered a non-null reference.

Uma referência anulada também pode ser explicitamente tratada como x! não nula com o operador postfix (o operador "damnit"), pois quando a análise de fluxo não pode estabelecer uma situação não nula que o desenvolvedor sabe que está lá.A nullable reference can also explicitly be treated as non-null with the postfix x! operator (the "damnit" operator), for when flow analysis cannot establish a non-null situation that the developer knows is there.

Caso contrário, um aviso é dado se uma referência anulada for desreferenciada ou for convertida em um tipo não nulo.Otherwise, a warning is given if a nullable reference is dereferenced, or is converted to a non-null type.

Um aviso é dado S[] T?[] ao S?[] converter T[]de e para .A warning is given when converting from S[] to T?[] and from S?[] to T[].

Um aviso é dado C<S> C<T?> ao converter de para exceçãooutquando o parâmetro C<S?> C<T> de tipo é covariantein( ), e ao converter-se para exceção quando o parâmetro de tipo é contravariante ( ).A warning is given when converting from C<S> to C<T?> except when the type parameter is covariant (out), and when converting from C<S?> to C<T> except when the type parameter is contravariant (in).

Um aviso é C<T?> dado se o parâmetro de tipo tiver restrições não nulas.A warning is given on C<T?> if the type parameter has non-null constraints.

Verificação de referências não nulasChecking of non-null references

Um aviso é dado se um literal nulo for atribuído a uma variável não nula ou passado como um parâmetro não nulo.A warning is given if a null literal is assigned to a non-null variable or passed as a non-null parameter.

Um aviso também é dado se um construtor não inicializar explicitamente campos de referência não nulos.A warning is also given if a constructor does not explicitly initialize non-null reference fields.

Não podemos rastrear adequadamente que todos os elementos de uma matriz de referências não nulas são inicializados.We cannot adequately track that all elements of an array of non-null references are initialized. No entanto, podemos emitir um aviso se nenhum elemento de uma matriz recém-criada for atribuído antes que a matriz seja lida ou transmitida.However, we could issue a warning if no element of a newly created array is assigned to before the array is read from or passed on. Isso pode lidar com o caso comum sem ser muito barulhento.That might handle the common case without being too noisy.

Precisamos decidir se default(T) gera um aviso, ou é simplesmente T?tratado como sendo do tipo.We need to decide whether default(T) generates a warning, or is simply treated as being of the type T?.

Representação de metadadosMetadata representation

Os adornos de nulidade devem ser representados em metadados como atributos.Nullability adornments should be represented in metadata as attributes. Isso significa que compiladores de baixo nível os ignorarão.This means that downlevel compilers will ignore them.

Precisamos decidir se apenas anotações anuladas estão incluídas, ou há também alguma indicação de se não-nulo estava "ligado" na assembléia.We need to decide if only nullable annotations are included, or there's also some indication of whether non-null was "on" in the assembly.

GenéricosGenerics

Se um parâmetro T de tipo tiver restrições não anuladas, ele é tratado como não anulado dentro de seu escopo.If a type parameter T has non-nullable constraints, it is treated as non-nullable within its scope.

Se um parâmetro de tipo não for constrangido ou tiver apenas restrições anuladas, a situação é um pouco mais complexa: isso significa que o argumento do tipo correspondente pode ser nulo ou não.If a type parameter is unconstrained or has only nullable constraints, the situation is a little more complex: this means that the corresponding type argument could be either nullable or non-nullable. A coisa segura a fazer nessa situação é tratar o parâmetro do tipo como nulo e não anulado, dando avisos quando ambos são violados.The safe thing to do in that situation is to treat the type parameter as both nullable and non-nullable, giving warnings when either is violated.

Vale a pena considerar se devem ser permitidas restrições explícitas de referência anuladas.It is worth considering whether explicit nullable reference constraints should be allowed. Note, no entanto, que não podemos evitar que tipos de referência nulos sejam implicitamente restrições em certos casos (restrições herdadas).Note, however, that we cannot avoid having nullable reference types implicitly be constraints in certain cases (inherited constraints).

A class restrição não é nula.The class constraint is non-null. Podemos considerar class? se deve ser uma restrição anulada válida denotando "tipo de referência nulo".We can consider whether class? should be a valid nullable constraint denoting "nullable reference type".

Inferência de tipoType inference

Na inferência de tipo, se um tipo contribuinte for um tipo de referência anulado, o tipo resultante deve ser anulado.In type inference, if a contributing type is a nullable reference type, the resulting type should be nullable. Em outras palavras, a nulidade é propagada.In other words, nullness is propagated.

Devemos considerar se null o literal como expressão participante deve contribuir com a nulidade.We should consider whether the null literal as a participating expression should contribute nullness. Não funciona hoje: para tipos de valor, leva a um erro, enquanto para tipos de referência o nulo converte com sucesso para o tipo simples.It doesn't today: for value types it leads to an error, whereas for reference types the null successfully converts to the plain type.

string? n = "world";
var x = b ? "Hello" : n; // string?
var y = b ? "Hello" : null; // string? or error
var z = b ? 7 : null; // Error today, could be int?

Orientação de guarda nulaNull guard guidance

Como recurso, os tipos de referência anulados permitem que os desenvolvedores expressem suas intenções e forneçam avisos através da análise de fluxo se essa intenção for contraditória.As a feature, nullable reference types allow developers to express their intent, and provide warnings through flow analysis if that intent is contradicted. Há uma pergunta comum sobre se guardas nulos são ou não necessários.There is a common question as to whether or not null guards are necessary.

Exemplo de guarda nuloExample of null guard

public void DoWork(Worker worker)
{
    // Guard against worker being null
    if (worker is null)
    {
        throw new ArgumentNullException(nameof(worker));
    }

    // Otherwise use worker argument
}

No exemplo anterior, DoWork a função Worker aceita um e nullprotege contra ela potencialmente ser .In the previous example, the DoWork function accepts a Worker and guards against it potentially being null. Se worker o nullargumento DoWork for, throwa função irá .If the worker argument is null, the DoWork function will throw. Com tipos de referência anulados, o código no Worker exemplo anterior nullfaz a intenção de que o parâmetro não seria .With nullable reference types, the code in the previous example makes the intent that the Worker parameter would not be null. Se DoWork a função era uma API pública, como um pacote NuGet ou uma biblioteca compartilhada - como orientação, você deve deixar guardas nulos no lugar.If the DoWork function was a public API, such as a NuGet package or a shared library - as guidance you should leave null guards in place. Como uma API pública, a única garantia null de que um interlocutor não está passando é se proteger contra ela.As a public API, the only guarantee that a caller isn't passing null is to guard against it.

Intenção expressaExpress intent

Um uso mais convincente do exemplo anterior Worker é expressar nullque o parâmetro poderia ser, tornando assim a guarda nula mais apropriada.A more compelling use of the previous example is to express that the Worker parameter could be null, thus making the null guard more appropriate. Se você remover o protetor nulo no exemplo a seguir, o compilador avisará que você pode estar desfazendo nulo.If you remove the null guard in the following example, the compiler warns that you may be dereferencing null. Independentemente disso, ambos os guardas nulos ainda são válidos.Regardless, both null guards are still valid.

public void DoWork(Worker? worker)
{
    // Guard against worker being null
    if (worker is null)
    {
        throw new ArgumentNullException(nameof(worker));
    }

    // Otherwise use worker argument
}

Para APIs não públicas, como código fonte inteiramente controlado por um desenvolvedor ou equipe de desenvolvimento - os tipos de referência anulados poderiam permitir a remoção segura de guardas nulos onde os desenvolvedores podem garantir que não é necessário.For non-public APIs, such as source code entirely in control by a developer or dev team - the nullable reference types could allow for the safe removal of null guards where the developers can guarantee it is not necessary. O recurso pode ajudar com avisos, mas não pode garantir NullReferenceExceptionque a execução do código em tempo de execução pode resultar em um .The feature can help with warnings, but it cannot guarantee that at runtime code execution could result in a NullReferenceException.

Alterações de quebraBreaking changes

Os avisos não nulos são uma mudança óbvia no código existente e devem ser acompanhados de um mecanismo de opt-in.Non-null warnings are an obvious breaking change on existing code, and should be accompanied with an opt-in mechanism.

Menos obviamente, os avisos de tipos anulados (como descrito acima) são uma mudança de quebra no código existente em certos cenários onde a nulidade está implícita:Less obviously, warnings from nullable types (as described above) are a breaking change on existing code in certain scenarios where the nullability is implicit:

  • Os parâmetros de tipo sem restrições serão tratados object como implicitamente nulos, de modo que atribuí-los ou acessar, por exemplo, ToString produzirá avisos.Unconstrained type parameters will be treated as implicitly nullable, so assigning them to object or accessing e.g. ToString will yield warnings.
  • se a inferência de tipo null inferir a nulidade das expressões, o código existente às vezes produzirá tipos anulados em vez de não anulados, o que pode levar a novos avisos.if type inference infers nullness from null expressions, then existing code will sometimes yield nullable rather than non-nullable types, which can lead to new warnings.

Portanto, avisos anulados também precisam ser opcionaisSo nullable warnings also need to be optional

Finalmente, adicionar anotações a uma API existente será uma mudança de ruptura para os usuários que optaram por avisos, quando atualizarem a biblioteca.Finally, adding annotations to an existing API will be a breaking change to users who have opted in to warnings, when they upgrade the library. Isso, também, merece a capacidade de optar por entrar ou sair. "Eu quero as correções de erro, mas eu não estou pronto para lidar com suas novas anotações"This, too, merits the ability to opt in or out. "I want the bug fixes, but I am not ready to deal with their new annotations"

Em resumo, você precisa ser capaz de optar por:In summary, you need to be able to opt in/out of:

  • Avisos anuladosNullable warnings
  • Avisos não nulosNon-null warnings
  • Avisos de anotações em outros arquivosWarnings from annotations in other files

A granularidade do opt-in sugere um modelo semelhante ao analisador, onde faixas de código podem optar por entrar e sair com pragmas e níveis de gravidade podem ser escolhidos pelo usuário.The granularity of the opt-in suggests an analyzer-like model, where swaths of code can opt in and out with pragmas and severity levels can be chosen by the user. Além disso, as opções por biblioteca ("ignore as anotações de JSON.NET até que eu esteja pronto para lidar com a queda") podem ser expressíveis em código como atributos.Additionally, per-library options ("ignore the annotations from JSON.NET until I'm ready to deal with the fall out") may be expressible in code as attributes.

O design da experiência opt-in/transição é crucial para o sucesso e utilidade deste recurso.The design of the opt-in/transition experience is crucial to the success and usefulness of this feature. Precisamos ter certeza de que:We need to make sure that:

  • Os usuários podem adotar a verificação de nulidade gradualmente como eles queremUsers can adopt nullability checking gradually as they want to
  • Autores de bibliotecas podem adicionar anotações de nulidade sem medo de quebrar clientesLibrary authors can add nullability annotations without fear of breaking customers
  • Apesar disso, não há uma sensação de "pesadelo de configuração"Despite these, there is not a sense of "configuration nightmare"

AjustesTweaks

Poderíamos considerar não ? usar as anotações nos locais, mas apenas observar se elas são usadas de acordo com o que lhes é atribuído.We could consider not using the ? annotations on locals, but just observing whether they are used in accordance with what gets assigned to them. Eu não sou a favor disso. Acho que devemos deixar as pessoas expressarem suas intenções.I don't favor this; I think we should uniformly let people express their intent.

Poderíamos considerar uma T! x taquigrafia nos parâmetros, que gera automaticamente uma verificação nula em tempo de execução.We could consider a shorthand T! x on parameters, that auto-generates a runtime null check.

Certos padrões em tipos FirstOrDefault TryGetgenéricos, como ou , têm um comportamento ligeiramente estranho com argumentos de tipo não anulados, porque eles explicitamente produzem valores padrão em determinadas situações.Certain patterns on generic types, such as FirstOrDefault or TryGet, have slightly weird behavior with non-nullable type arguments, because they explicitly yield default values in certain situations. Poderíamos tentar nuances do sistema tipo para acomodar estes melhor.We could try to nuance the type system to accommodate these better. Por exemplo, poderíamos ? permitir parâmetros de tipo sem restrições, mesmo que o argumento do tipo já pudesse ser anulado.For instance, we could allow ? on unconstrained type parameters, even though the type argument could already be nullable. Duvido que valha a pena, e isso leva a estranheza relacionada à interação com tipos de valor anulados.I doubt that it is worth it, and it leads to weirdness related to interaction with nullable value types.

Tipos de valor anuláveisNullable value types

Poderíamos considerar a adoção de algumas das semânticas acima para tipos de valor anulados também.We could consider adopting some of the above semantics for nullable value types as well.

Já mencionamos inferência de tipo, int? (7, null)de onde poderíamos inferir, em vez de apenas dar um erro.We already mentioned type inference, where we could infer int? from (7, null), instead of just giving an error.

Outra oportunidade é aplicar a análise de fluxo a tipos de valor anulados.Another opportunity is to apply the flow analysis to nullable value types. Quando eles forem considerados não nulos, poderíamos realmente permitir o uso como o tipo não anulado de certas maneiras (por exemplo, acesso ao membro).When they are deemed non-null, we could actually allow using as the non-nullable type in certain ways (e.g. member access). Só temos que ter cuidado para que as coisas que você pode fazer em um tipo de valor anulado serão preferidas, por razões de retorno.We just have to be careful that the things that you can already do on a nullable value type will be preferred, for back compat reasons.