C# Language
Voorwaardelijke exploitanten

Syntaxis

• X .Y?; // null als X null is anders XY
• ? X Y. .Z?; // null als X null is of Y null, anders XYZ
• X [index]; // null als X null is anders X [index]
• X .ValueMethod (?); // null als X null is, anders is het resultaat van X.ValueMethod ();
• X .VoidMethod (?); // doe niets als X null is anders roep X.VoidMethod () aan;

Opmerkingen

Null-voorwaardelijke operator

De ?. operator is syntactische suiker om uitgebreide nulcontroles te voorkomen. Het wordt ook wel de veilige navigatie-operator genoemd .

Klasse gebruikt in het volgende voorbeeld:

public class Person
{
    public int Age { get; set; }
    public string Name { get; set; }
    public Person Spouse { get; set; }
}

Als een object mogelijk null is (zoals een functie die een referentietype retourneert), moet het object eerst op null worden gecontroleerd om een mogelijke NullReferenceException te voorkomen. Zonder de nul-voorwaardelijke operator zou dit er als volgt uitzien:

Person person = GetPerson();

int? age = null;
if (person != null)
    age = person.Age;

Hetzelfde voorbeeld met de null-voorwaardelijke operator:

Person person = GetPerson();

var age = person?.Age;    // 'age' will be of type 'int?', even if 'person' is not null

De operator ketenen

De null-voorwaardelijke operator kan worden gecombineerd met de leden en subleden van een object.

// Will be null if either `person` or `person.Spouse` are null
int? spouseAge = person?.Spouse?.Age;

Combineren met de nul-coalescerende operator

De nul-voorwaardelijke operator kan worden gecombineerd met de nul-coalescerende operator om een standaardwaarde te bieden:

// spouseDisplayName will be "N/A" if person, Spouse, or Name is null
var spouseDisplayName = person?.Spouse?.Name ?? "N/A";

De nul-voorwaardelijke index

Op dezelfde manier als de ?. operator, controleert de null-voorwaardelijke indexoperator op nulwaarden bij het indexeren in een verzameling die mogelijk null is.

string item = collection?[index];

is syntactische suiker voor

string item = null;
if(collection != null)
{
    item = collection[index];
}

NullReferenceExceptions vermijden

var person = new Person
{
    Address = null;
};

var city = person.Address.City; //throws a NullReferenceException
var nullableCity = person.Address?.City; //returns the value of null

Dit effect kan aan elkaar worden gekoppeld:

var person = new Person
{
    Address = new Address
    {
        State = new State
        {
            Country = null
        }
    }
};

// this will always return a value of at least "null" to be stored instead
// of throwing a NullReferenceException
var countryName = person?.Address?.State?.Country?.Name; 

Null-conditionele operator kan worden gebruikt met de uitbreidingsmethode

Extensiemethode kan op nulreferenties werken , maar u kunt ?. hoe dan ook null-check.

public class Person 
{
    public string Name {get; set;}
}

public static class PersonExtensions
{
    public static int GetNameLength(this Person person)
    {
        return person == null ? -1 : person.Name.Length;
    }
}

Normaal gesproken wordt de methode geactiveerd voor null en retourneert -1:

Person person = null;
int nameLength = person.GetNameLength(); // returns -1

Gebruiken ?. de methode wordt niet geactiveerd voor null en het type is int? :

Person person = null;
int? nameLength = person?.GetNameLength(); // nameLength is null.

Dit gedrag wordt eigenlijk verwacht van de manier waarop de ?. operator werkt: het zal voorkomen dat het maken van instantiemethoden null-instances veroorzaakt, om NullReferenceExceptions te voorkomen. Dezelfde logica is echter van toepassing op de uitbreidingsmethode, ondanks het verschil in hoe de methode wordt verklaard.

Voor meer informatie over waarom de uitbreidingsmethode in het eerste voorbeeld wordt aangeroepen, zie de uitbreidingsmethoden - documentatie voor null-controle .