Dlaczego C# wymaga nawiasów przy użyciu nullables w wyrażeniu?

Question

Jestem nowym do C# i badając cechy językowe, natknąłem się coś dziwnego:

struct Foo 
{ 
    public Foo Identity() { return this; } 

    public static void Bar(Foo? foo) 
    { 
     Foo foo1 = foo?.Identity().Value; // Does not compile 
     Foo foo2 = (foo?.Identity()).Value; // Compiles 
    } 
} 

Czy ktoś może mi wyjaśnić dlaczego nawias są potrzebne?

Answer 1

Czy ktoś mógłby mi wytłumaczyć, dlaczego potrzebne są nawiasy?

ponieważ Identity() powraca ma Foo (nie Foo?), a zatem nie Value nieruchomości. Jeśli foo ma wartość NULL, wartość pusta będzie propagowana przez wywołanie Identity.

Kiedy można umieścić nawiasy wokół niego, wyniki ekspresjijest Nullable<Foo> który robi mają właściwość Value.

Należy również pamiętać, że jeśli foojest null, wtedy będzie nazywając Value na Nullable<Foo> który nie ma wartości, a dostaniesz wyjątek w czasie wykonywania. Niektóre analizatory statyczne rozpoznają, że możliwe jest wystąpienie wyjątku o wartości zerowej oczekującej na wystąpienie i ostrzeżenie.

Jeśli rozszerzyć je do swoich odpowiedników bez zerowego propagacji będzie bardziej jasne:

Foo foo1; 
if(foo != null) 
{ 
    foo1 = foo.Identity().Value; // not possible - Foo has no Value property. 
} 
else 
{ 
    foo1 = null; // also not possible 
} 

Foo foo2; 
Foo? temp; 
if(foo != null) 
{ 
    temp = foo.Identity(); 
} 
else 
{ 
    temp = null; // actually a Nullable<Foo> with no value 
} 
foo2 = temp.Value; // legal, but will throw an exception at run-time if foo is null 

If Identity() powraca Foo, dlaczego Foo foo3 = foo?.Identity(); nie skompilować?

Równowartość że byłoby:

Foo foo3 
if(foo != null) 
{ 
    foo3 = foo.Identity(); 
} 
else 
{ 
    foo3 = null; // not possible 
} 

Answer 2

myślę, że była to dobra decyzja z zespołu C#, aby zrobić to w ten sposób. Rozważmy poniższy scenariusz:

Jeśli struct było:

struct Foo 
{ 
    public int ID { set; get; } 

    public Foo Identity() { return this; } 

    public static void Bar(Foo? foo) 
    { 
     int? foo1 = foo?.Identity().ID; // compile 
     Foo foo2 = (foo?.Identity()).Value; // Compiles 
    } 
} 

Jeśli nie potrzebują nawias dostępu do pustych wynik, nie będzie w stanie uzyskać dostępu do właściwości ID. Ponieważ nie będzie skompilować poniżej:

int? foo2 = (foo?.Identity()).GetValueOrDefault()?.ID 

Kiedy piszesz foo?.Identity(). co jest po . jest typu Foo zwróconej przez Identity(). Jednak w (foo?.Identity()). co jest po . jest Foo? który jest rzeczywisty wynik całego rachunku foo?.Identity().