C# Language
Operatory nieuwarunkowane

Składnia

• X? .Y; // null, jeśli X jest null, inaczej XY
• X? .Y? .Z; // null, jeśli X jest null lub Y jest null, w przeciwnym razie XYZ
• X? [Indeks]; // null, jeśli X jest null, w przeciwnym razie X [indeks]
• X? .ValueMethod (); // null, jeśli X jest null, w przeciwnym razie wynik X.ValueMethod ();
• X? .VoidMethod (); // nic nie rób, jeśli X ma wartość null, w przeciwnym razie wywołaj X.VoidMethod ();

Uwagi

Operator nieważny

?. operator jest składniowym cukrem, aby uniknąć pełnych kontroli zerowych. Jest również znany jako operator Bezpiecznej nawigacji .

Klasa użyta w następującym przykładzie:

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

Jeśli obiekt ma potencjalnie wartość NULL (taką jak funkcja zwracająca typ odwołania), należy najpierw sprawdzić obiekt pod kątem wartości NULL, aby zapobiec możliwemu wyjątkowi NullReferenceException . Bez operatora warunkowego zerowego wyglądałoby to tak:

Person person = GetPerson();

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

Ten sam przykład z wykorzystaniem operatora zerowego-warunkowego:

Person person = GetPerson();

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

Łańcuch operatora

Operator warunkowy o wartości zerowej można łączyć na elementach i elementach podrzędnych obiektu.

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

W połączeniu z operatorem zerowania koalescencji

Operator zerowo-warunkowy można połączyć z operatorem zerowo-koalescencyjnym, aby uzyskać wartość domyślną:

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

Indeks zerowy-warunkowy

Podobnie jak ?. operator, operator indeksu warunkowego null sprawdza wartości null podczas indeksowania do kolekcji, która może być null.

string item = collection?[index];

jest cukrem syntaktycznym dla

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

Unikanie wyjątków NullReferenceException

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

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

Ten efekt można połączyć razem:

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; 

Operator zerowy-warunkowy może być używany z Metodą rozszerzenia

Metoda rozszerzenia może działać na referencjach zerowych , ale możesz użyć ?. i tak sprawdzić zerowo.

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

Zwykle metoda zostanie uruchomiona dla odwołań null i zwróci -1:

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

Używasz ?. metoda nie zostanie uruchomiona dla referencji o null , a typem jest int? :

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

Tego zachowania można się spodziewać po sposobie, w jaki ?. operator działa: uniknie wywoływania metod instancji dla instancji zerowych, aby uniknąć NullReferenceExceptions . Jednak ta sama logika dotyczy metody rozszerzenia, pomimo różnicy w sposobie deklarowania metody.

Aby uzyskać więcej informacji o tym, dlaczego metoda rozszerzenia jest wywoływana w pierwszym przykładzie, zobacz Metody metod rozszerzenia - dokumentacja sprawdzania wartości zerowej .