web-dev-qa-db-fra.com

Qu'est-ce que le point d'interrogation et l'opérateur de points? signifie en C # 6.0?

Avec l'aperçu VS2015 avec C # 6.0, nous avons un nouvel opérateur, ?., qui peut être utilisé comme ceci:

_public class A {
   string PropertyOfA { get; set; }
}

...

var a = new A();
var foo = "bar";
if(a?.PropertyOfA != foo) {
   //somecode
}
_

Qu'est-ce que cela fait exactement?

c#operatorsc#-6.0
293
Landeeyo

C'est l'opérateur null conditionnel . Cela signifie fondamentalement:

"Evalue le premier opérande; si c'est null, arrête, avec un résultat nul. Sinon, évalue le deuxième opérande (en tant qu'accès membre du premier opérande)."

Dans votre exemple, le fait est que si a est null, alors a?.PropertyOfA sera évalué à null au lieu de déclencher une exception. Il comparera alors cette référence null à foo (à l'aide de la surcharge == de la chaîne), constatera qu'elles ne sont pas égales et l'exécution Entrez dans le corps de la déclaration if.

En d'autres termes, c'est comme ça:

string bar = (a == null ? null : a.PropertyOfA);
if (bar != foo)
{
    ...
}

... sauf que a n'est évalué qu'une fois.

Notez que cela peut aussi changer le type de l'expression. Par exemple, considérons FileInfo.Length . C'est une propriété de type long, mais si vous l'utilisez avec l'opérateur conditionnel null, vous obtenez une expression de type long?:

FileInfo fi = ...; // fi could be null
long? length = fi?.Length; // If fi is null, length will be null
414
Jon Skeet

Cela peut être très utile pour aplatir une hiérarchie et/ou des objets de mappage. Au lieu de:

if (Model.Model2 == null
  || Model.Model2.Model3 == null
  || Model.Model2.Model3.Model4 == null
  || Model.Model2.Model3.Model4.Name == null)
{
  mapped.Name = "N/A"
}
else
{
  mapped.Name = Model.Model2.Model3.Model4.Name;
}

Cela peut être écrit comme (même logique que ci-dessus)

mapped.Name = Model.Model2?.Model3?.Model4?.Name ?? "N/A";

Exemple de travail DotNetFiddle.Net .

(le opérateur ?? ou nul-coalescent est différent du ? ou? ou l'opérateur conditionnel nul ).

Il peut également être utilisé en dehors des opérateurs d'affectation avec Action. Au lieu de

Action<TValue> myAction = null;

if (myAction != null)
{
  myAction(TValue);
}

Il peut être simplifié pour:

myAction?.Invoke(TValue);

Exemple DotNetFiddle :

en utilisant le système;

public class Program
{
  public static void Main()
  {
    Action<string> consoleWrite = null;

    consoleWrite?.Invoke("Test 1");

    consoleWrite = (s) => Console.WriteLine(s);

    consoleWrite?.Invoke("Test 2");
  }
}

Résultat:

Test 2

66
Erik Philips

Ceci est relativement nouveau en C #, ce qui nous permet d’appeler facilement les fonctions en ce qui concerne les valeurs null ou non-null dans l’enchaînement de méthodes.

l’ancien moyen de parvenir à la même chose était:

var functionCaller = this.member;
if (functionCaller!= null)
    functionCaller.someFunction(var someParam);

et maintenant cela a été rendu beaucoup plus facile avec juste:

member?.someFunction(var someParam);

Je vous recommande fortement de le lire ici:

https://docs.Microsoft.com/en-us/dotnet/csharp/language-reference/operators/null-conditional-operators

2
Zeeshan Adil