C# Language
Nullbedingte Operatoren

Syntax

• X? .Y; // null, wenn X null ist, sonst XY
• X & le; Y & le; Z; // Null, wenn X Null oder Y Null ist, sonst XYZ
• X [Index]; // Null, wenn X Null ist, sonst X [Index]
• X? .ValueMethod (); // null wenn X gleich null ist sonst das Ergebnis von X.ValueMethod ();
• X.VoidMethod (); // nichts tun, wenn X null ist, sonst Aufruf X.VoidMethod ();

Bemerkungen

Nullbedingter Operator

Die ?. Operator ist syntaktischer Zucker, um ausführliche Nullprüfungen zu vermeiden. Es ist auch als der sichere Navigationsoperator bekannt .

Klasse, die im folgenden Beispiel verwendet wird:

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

Wenn ein Objekt möglicherweise null ist (z. B. eine Funktion, die einen Referenztyp zurückgibt), muss das Objekt zuerst auf null überprüft werden, um eine mögliche NullReferenceException zu verhindern. Ohne den nullbedingten Operator würde dies folgendermaßen aussehen:

Person person = GetPerson();

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

Dasselbe Beispiel mit dem null-bedingten Operator:

Person person = GetPerson();

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

Verkettung des Bedieners

Der nullbedingte Operator kann für die Member und Submitglieder eines Objekts kombiniert werden.

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

Kombination mit dem Nullkoaleszenzoperator

Der nullbedingte Operator kann mit dem nullkoaleszierenden Operator kombiniert werden , um einen Standardwert bereitzustellen:

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

Der null-bedingte Index

Ähnlich wie das ?. operator, überprüft der nullbedingte Indexoperator bei der Indizierung in eine Sammlung, die möglicherweise null ist, auf Nullwerte

string item = collection?[index];

ist syntaktischer Zucker für

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

NullReferenceExceptions vermeiden

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

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

Dieser Effekt kann miteinander verkettet werden:

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; 

Der bedingungslose Operator kann mit der Erweiterungsmethode verwendet werden

Die Erweiterungsmethode kann mit Nullreferenzen arbeiten , Sie können jedoch ?. Verwenden ?. Null-Check trotzdem.

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

Normalerweise wird die Methode für null ausgelöst und gibt -1 zurück:

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

Verwenden von ?. Die Methode wird nicht für null ausgelöst und der Typ ist int? :

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

Dieses Verhalten wird eigentlich von der Art und Weise erwartet, in der das ?. Der Operator funktioniert: Es werden keine Instanzmethodenaufrufe für NullReferenceExceptions , um NullReferenceExceptions zu vermeiden. Die gleiche Logik gilt jedoch für die Erweiterungsmethode, auch wenn die Methode unterschiedlich ist.

Weitere Informationen dazu, warum die Erweiterungsmethode im ersten Beispiel aufgerufen wird, finden Sie in der Dokumentation Erweiterungsmethoden - Nullprüfung .