C# Language
Nollvillkorade operatörer

Syntax

• X .Y; // null om X är noll annars XY
• ? X .Y .Z; // null om X är noll eller Y är noll annars XYZ
• X [index]?; // null om X är noll annars X [index]
• X .ValueMethod (); // null om X är noll annars är resultatet av X.ValueMethod ();
• X .VoidMethod (); // gör ingenting om X är noll annars ring X.VoidMethod ();

Anmärkningar

Noll-villkorad operatör

?. operatören är syntaktiskt socker för att undvika fullständiga nollkontroller. Det är också känt som Safe navigation operator .

Klass som används i följande exempel:

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

Om ett objekt potentiellt är noll (till exempel en funktion som returnerar en referenstyp) måste objektet först kontrolleras för null för att förhindra en eventuell NullReferenceException . Utan den nollvillkorade operatören skulle detta se ut:

Person person = GetPerson();

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

Samma exempel med den nollvillkorade operatören:

Person person = GetPerson();

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

Kedja operatören

Den nollvillkorade operatören kan kombineras på ett objekts medlemmar och undermedlemmar.

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

Kombination med Null-Coalescing Operator

Operatören med nollvillkor kan kombineras med operatören nollkoaliserande för att tillhandahålla ett standardvärde:

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

Noll-villkorligt index

På samma sätt som ?. operatören, kontrollerar den nollvillkorade indexoperatören efter nollvärden vid indexering i en samling som kan vara noll.

string item = collection?[index];

är syntaktiskt socker för

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

Undvika NullReferenceExceptions

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

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

Denna effekt kan kedjas ihop:

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; 

Noll-villkorad operatör kan användas med förlängningsmetod

Extensionsmetod kan fungera på nollreferenser , men du kan använda ?. att ändå nollkontrollera.

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

Normalt utlöses metoden för null och returnerar -1:

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

Använder ?. metoden kommer inte att triggas för null , och typen är int? :

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

Detta beteende förväntas faktiskt från det sätt på vilket ?. operatören fungerar: den kommer att undvika att NullReferenceExceptions för att undvika NullReferenceExceptions . Men samma logik gäller förlängningsmetoden, trots skillnaden i hur metoden deklareras.

För mer information om varför tilläggsmetoden kallas i det första exemplet, se tilläggsmetoderna - nollkontroll dokumentation.