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 a
null
is, a?.PropertyOfA
zal evalueren tot null
in 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 a
maar éé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);
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.