C# Language
Null-coalescerende operator

Syntaxis

• var result = mogelijkNullObject ?? standaardwaarde;

parameters

Opmerkingen

possibleNullObject != null ? possibleNullObject : defaultValue

Basis gebruik

Met de null-coalescing operator (??) kunt u een standaardwaarde opgeven voor een nullable-type als de operand aan de linkerkant null .

string testString = null;
Console.WriteLine("The specified string is - " + (testString ?? "not provided"));

Live demo op .NET Fiddle

Dit komt logisch overeen met:

string testString = null;
if (testString == null)
{
    Console.WriteLine("The specified string is - not provided");
}
else
{
    Console.WriteLine("The specified string is - " + testString);
}

of gebruik de ternaire operator (? :) operator:

string testString = null;
Console.WriteLine("The specified string is - " + (testString == null ? "not provided" : testString));

Nuldoorval en kettingvorming

De linker operand moet nul zijn, terwijl de rechter operand al dan niet kan zijn. Het resultaat wordt dienovereenkomstig getypt.

Non-nullable

int? a = null;
int b = 3;
var output = a ?? b;
var type = output.GetType();  

Console.WriteLine($"Output Type :{type}");
Console.WriteLine($"Output value :{output}");

Output:

Type: System.Int32
waarde: 3

Demo bekijken

nullable

int? a = null;
int? b = null;
var output = a ?? b;

output zal van het type int? en gelijk aan b , of null .

Meerdere samenvoeging

Coalescing kan ook worden gedaan in ketens:

int? a = null;
int? b = null;
int c = 3;
var output = a ?? b ?? c;

var type = output.GetType();    
Console.WriteLine($"Type :{type}");
Console.WriteLine($"value :{output}");

Output:

Type: System.Int32
waarde: 3

Demo bekijken

Voorwaardelijke kettingregeling null

De nul-coalescente-operator kan worden gebruikt in combinatie met de nul-propagatie-operator om veiligere toegang tot eigenschappen van objecten te bieden.

object o = null;
var output = o?.ToString() ?? "Default Value";

Output:

Type: System.String
waarde: standaardwaarde

Demo bekijken

Null coalescerende operator met methodeaanroepen

Met de coalescente-operator voor nul kunt u er eenvoudig voor zorgen dat een methode die null retourneert, terugvalt naar een standaardwaarde.

Zonder de nulcoalescente-operator:

string name = GetName();

if (name == null)
    name = "Unknown!";

Met de nulcoalescente-operator:

string name = GetName() ?? "Unknown!";

Gebruik bestaand of maak nieuw

Een veel voorkomend gebruiksscenario waar deze functie echt bij helpt, is wanneer u op zoek bent naar een object in een verzameling en een nieuw moet maken als het nog niet bestaat.

IEnumerable<MyClass> myList = GetMyList();
var item = myList.SingleOrDefault(x => x.Id == 2) ?? new MyClass { Id = 2 };

Lazy initialisatie van eigenschappen met nul coalescente operator

private List<FooBar> _fooBars;

public List<FooBar> FooBars
{
    get { return _fooBars ?? (_fooBars = new List<FooBar>()); }
}

De eerste keer dat de eigenschap .FooBars wordt gebruikt, zal de variabele _fooBars als null worden geëvalueerd, waardoor de opdracht wordt toegewezen aan de resulterende waarde.

Draad veiligheid

Dit is geen draadveilige manier om luie eigenschappen te implementeren. Gebruik voor draadveilige luiheid de Lazy<T> -klasse ingebouwd in het .NET Framework.

C # 6 Syntactische suiker met expressie-lichamen

Merk op dat sinds C # 6 deze syntax kan worden vereenvoudigd met behulp van expression body voor de eigenschap:

private List<FooBar> _fooBars;

public List<FooBar> FooBars => _fooBars ?? ( _fooBars = new List<FooBar>() );

Latere toegangen tot de eigenschap leveren de waarde op die is opgeslagen in de variabele _fooBars .

Voorbeeld in het MVVM-patroon

Dit wordt vaak gebruikt bij het implementeren van opdrachten in het MVVM-patroon. In plaats van de opdrachten gretig te initialiseren met de constructie van een viewmodel, worden opdrachten lui geïnitialiseerd met behulp van dit patroon als volgt:

private ICommand _actionCommand = null;
public ICommand ActionCommand =>
   _actionCommand ?? ( _actionCommand = new DelegateCommand( DoAction ) );