Pourquoi C# nécessite-t-il des parenthèses lors de l'utilisation de valeurs nulles dans une expression?

Question

Je suis nouveau sur C# et tout en explorant les caractéristiques linguistiques, je suis tombé sur quelque chose d'étrange:

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 
    } 
} 

Quelqu'un pourrait-il me expliquer pourquoi les parenthèses sont nécessaires?

Answer 1

Quelqu'un pourrait-il m'expliquer pourquoi les parenthèses sont nécessaires?

Because Identity() renvoie un Foo (pas Foo?) et n'a donc pas la propriété Value. Si foo est null, la valeur null sera propagée via l'appel Identity.

Lorsque vous mettez entre parenthèses autour d'elle, les résultats de l'expression est un Nullable<Foo> qui fait ont une propriété Value.

Notez également que si fooest nulle, alors vous serez appeler Value sur un Nullable<Foo> qui n'a pas de valeur, et aurez une exception lors de l'exécution. Certains analyseurs statiques reconnaîtront que vous avez une exception de référence nulle possible et vous préviendront.

Si vous les étendre à leurs équivalents sans nul propagation, il sera plus clair:

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 

Si Identity() retours Foo, pourquoi ne pas Foo foo3 = foo?.Identity(); compilez?

L'équivalent de ce serait:

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

Answer 2

Je pense que ce fut une bonne décision de l'équipe C# pour le faire de cette façon. Considérez le scénario ci-dessous:

Si la struct était:

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 
    } 
} 

Si vous ne l'avez pas besoin de la parenthèse pour accéder au résultat Nullable, vous ne seriez pas en mesure d'accéder à la propriété ID. Étant donné que le ci-dessous ne compilera pas:

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

Lorsque vous écrivez foo?.Identity(). ce qui est après la . est de type Foo retourné par Identity(). Cependant, dans (foo?.Identity()). ce qui est après la . est Foo? qui est le résultat réel de l'ensemble de la déclaration foo?.Identity().