Um tipo de referência não anulável no C # 8 pode ser nulo em tempo de execução?

10

Parece-me que realmente não há garantia de que uma variável não anulável nunca terá nulo. Imagine que eu tenho uma classe que possui uma propriedade que não é anulável:

public class Foo
{
    public Foo(string test)
    {
        Test = test;
    }
    public string Test {get;set;}
}

Agora, isso pode parecer que agora não pode ser nulo. Mas se fizermos referência a essa classe com outra biblioteca que não usa contexto nulo, nada impede que ele envie nulo lá.

Isso está correto ou há algumas verificações em tempo de execução, talvez, que garantam isso?

c# c#-8.0 nullable-reference-types

— Ilya Chernomordik
fonte

É public void Foo(string test){...}ou public Foo(string test){...}?

— HuMpty duMpty

Obrigado, eu consertei. Isso é o que acontece quando o homem confia muito em R # para gerar construtores :)

— Ilya Chernomordik

2

O C # 9 (provavelmente) adicionará validação nula simplificada .

— Steven

Em resumo, o recurso "tipos de referência anuláveis" está completamente quebrado.

— Alejandro

9

É o que a MS diz sobre ( https://docs.microsoft.com/en-us/dotnet/csharp/tutorials/upgrade-to-nullable-references#interfaces-with-external-code ):

O compilador não pode validar todas as chamadas para suas APIs públicas, mesmo que seu código seja compilado com os contextos de anotação anuláveis ativados. Além disso, suas bibliotecas podem ser consumidas por projetos que ainda não optaram por usar tipos de referência anuláveis. Valide entradas para APIs públicas, mesmo que você as tenha declarado como tipos não anuláveis.

— Dmitri Tsoy
fonte

2

alguém sempre pode fazer

var myFoo = new Foo(null);

Pode ser que você possa usar o Domain Driven Design

public class Foo
{
    public Foo(string test)
    {
         if (string.IsNullOrWhiteSpace(test))
             throw new ArgumentNullException(nameof(test));

         Test = test;
    }
    public string Test {get;private set;}
}

— huMpty duMpty
fonte

sim, você está certo, é apenas um aviso de qualquer maneira, eu acho. Espero que, no futuro, eles possam realmente aplicá-lo de alguma maneira, como, por exemplo, em Kotlin

— Ilya Chernomordik

2

Você está correto, outro código que não está usando o novo recurso pode atribuir nulo a essa propriedade; não há verificações em tempo de execução; são apenas dicas completas.

Você sempre pode fazer isso sozinho se quiser uma verificação de tempo de execução:

public string Test { get; set{ if (value == null) throw new ArgumentNullException() } }

Observe que você pode garantir que não seja nulo na maioria do seu código, basta adicionar guardas à API pública de nível superior e garantir que as classes sejam adequadamente seladas etc.

Claro que as pessoas ainda podem usar a reflexão para f *** seu código, mas então é sobre eles

— Milney
fonte

Portanto, isso efetivamente significa que ainda posso obter uma exceção de referência nula, mesmo que eu use um tipo não nulo, certo?

— Ilya Chernomordik

Bem ... você não pode no código que compila, porque você tem as dicas ... mas o código de outras pessoas que não têm dicas, mas faça referência ao seu código - sim, eles podem obter uma exceção nula

— Milney

Bem, se, por exemplo, um AutoMapper usa seu construtor, ou algo parecido, ainda que você é quem terá a exceção :)

— Ilya Chernomordik

Of course people can still use reflection to f*** your code up, verdadeiro, verdadeiro mesmo. Você definitivamente pode usar a reflexão para fazer isso, é recomendado , não , as pessoas ainda fazem isso, sim.

— Çöđěxěŕ

2

Mesmo em seu próprio código, se você optar por fazê-lo, poderá passar nullusando o operador que perdoa nulo. null!é considerado não nulo no que diz respeito à análise de nulidade do compilador.

— Damien_The_Unbeliever
fonte

-1

Para lidar com verificações nulas e também tornar seu código legível, sugiro o padrão Null Object Design.

Mais leitura aqui:

https://www.c-sharpcorner.com/article/null-object-design-pattern/

Basicamente, envolve a criação de um novo objeto derivado da mesma interface e com instância nula.

Exemplo:

public class NullExample : IExample  
{  
    private static NullExample _instance;  
    private NullExample()  
    { }  

    public static NullExample Instance  
    {  
        get {  
            if (_instance == null)  
                return new NullExample();  
            return _instance;  
        }  
    }  

    //do nothing methods  
    public void MethodImplementedByInterface1()  
    { }  

    public void MethodImplementedByInterface1()  
    { }  
}

Os nulos não podem ser evitados, mas podem ser verificados de maneira limpa.

— Gauravsa
fonte