Czy w środowisku wykonawczym typ odwołania nie dopuszczający wartości zerowej w C # 8 może mieć wartość NULL?

Wydaje mi się, że tak naprawdę nie ma gwarancji, że zmienna nie dopuszczająca wartości zerowej nigdy nie będzie miała wartości null. Wyobraź sobie, że mam klasę, która ma jedną właściwość, która nie ma wartości zerowej:

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

Teraz może się wydawać, że teraz nie może być zerowy. Ale jeśli odniesiemy tę klasę do innej biblioteki, która nie korzysta z kontekstu zerowalnego, nic nie powstrzyma jej przed wysłaniem wartości null.

Czy to jest poprawne, czy są też jakieś kontrole środowiska wykonawczego, które mogą to zapewnić?

O tym mówi MS ( https://docs.microsoft.com/en-us/dotnet/csharp/tutorials/upgrade-to-nullable-references#interfaces-with-external-code ):

Kompilator nie może zweryfikować wszystkich wywołań publicznych interfejsów API, nawet jeśli kod jest skompilowany z włączonymi kontekstami adnotacji z dopuszczaniem wartości zerowych. Co więcej, biblioteki mogą być wykorzystywane przez projekty, które jeszcze nie zdecydowały się na użycie zerowych typów referencji. Sprawdź poprawność danych wejściowych do publicznych interfejsów API, mimo że zadeklarowałeś je jako typy, które nie mają wartości NULL.

ktoś zawsze może to zrobić

var myFoo = new Foo(null);

Możliwe, że możesz użyć 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;}
}

Masz rację, inny kod, który nie korzysta z nowej funkcji, może przypisać null tej właściwości, nie ma żadnych kontroli w czasie wykonywania, to tylko wskazówki dotyczące zgodności.

Zawsze możesz to zrobić samodzielnie, jeśli chcesz sprawdzić środowisko wykonawcze:

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

Pamiętaj, że możesz zagwarantować, że nie będziesz mieć wartości zerowej w większości swojego kodu, wystarczy dodać zabezpieczenia do publicznego interfejsu API najwyższego poziomu i upewnić się, że klasy są odpowiednio zapieczętowane itp.

Oczywiście ludzie nadal mogą używać refleksji, aby sfałszować twój kod, ale potem jest on na nich

Nawet we własnym kodzie, jeśli zdecydujesz się to zrobić, możesz przekazać null, korzystając z operatora zerującego. null!jest uważany za wartość zerową, jeśli chodzi o analizę podatności kompilatora.

Aby poradzić sobie z zerowymi kontrolami i uczynić kod czytelnym, sugeruję wzorzec Null Object Design.

Więcej informacji tutaj:

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

Zasadniczo polega na utworzeniu nowego obiektu, który pochodzi z tego samego interfejsu i ma instancję zerową.

Przykład:

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()  
    { }  
}  

Wartości zerowych nie da się uniknąć, jednak można je dokładnie sprawdzić.