Wat betekent vraagteken en puntoperator ?. bedoel in C# 6.0?

Met C# 6.0 in de VS2015-preview hebben we een nieuwe operator, ?., die als volgt kan worden gebruikt:

public class A {
   string PropertyOfA { get; set; }
}
...
var a = new A();
var foo = "bar";
if(a?.PropertyOfA != foo) {
   //somecode
}

Wat doet het precies?

Antwoord 1, autoriteit 100%

Het is de null voorwaardelijkeoperator. Het betekent in feite:

“Evalueer de eerste operand; als dat null is, stop dan, met als resultaat null. Anders moet u de tweede operand evalueren (als lid toegang tot de eerste operand).”

In uw voorbeeld is het punt dat als anullis, a?.PropertyOfAzal evalueren tot nullin plaats van een uitzondering te maken – het zal dan die null-referentie vergelijken met foo(met behulp van string’s ==overbelasting), vind ze’ re niet gelijk is en de uitvoering zal in de hoofdtekst van de if-instructie komen.

Met andere woorden, het is als volgt:

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

… behalve dat amaar één keer wordt geëvalueerd.

Houd er rekening mee dat dit ook het type expressie kan veranderen. Denk bijvoorbeeld aan FileInfo.Length. Dat is een eigenschap van het type long, maar als je deze gebruikt met de voorwaardelijke operator null, krijg je een expressie van het type long?:

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

Antwoord 2, autoriteit 15%

Het kan erg handig zijn bij het afvlakken van een hiërarchie en/of het in kaart brengen van objecten. In plaats van:

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

Het kan worden geschreven als (dezelfde logica als hierboven)

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

DotNetFiddle.Net-werkvoorbeeld.

(de ?? of null -coalescing-operatoris anders dan de ? of null voorwaardelijke operator).

Het kan ook worden gebruikt buiten toewijzingsoperators met Action. In plaats van

Action<TValue> myAction = null;
if (myAction != null)
{
  myAction(TValue);
}

Het kan worden vereenvoudigd tot:

myAction?.Invoke(TValue);

DotNetFiddle-voorbeeld:

systeem gebruiken;

public class Program
{
  public static void Main()
  {
    Action<string> consoleWrite = null;
    consoleWrite?.Invoke("Test 1");
    consoleWrite = (s) => Console.WriteLine(s);
    consoleWrite?.Invoke("Test 2");
  }
}

Resultaat:

Test 2

Antwoord 3

Dit is relatief nieuw voor C#, wat het voor ons gemakkelijk maakt om de functies aan te roepen met betrekking tot de null- of niet-null-waarden in methodeketens.

de oude manier om hetzelfde te bereiken was:

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

en nu is het veel gemakkelijker gemaakt met slechts:

member?.someFunction(var someParam);

Ik raad dit document ten zeerste aan pagina.