Delen via

! (null-vergevingsgezinde) operator (C#-referentie)

De unaire postfix-operator ! is de null-vergevende of null-onderdrukkende operator. In een ingeschakelde context voor null-aantekening gebruikt u de operator null-forgiving om alle null-waarschuwingen voor de voorgaande expressie te onderdrukken. De unaire voorvoegseloperator ! is de logische negatieoperator. De operator null-forgiving heeft geen effect tijdens runtime. Dit is alleen van invloed op de statische stroomanalyse van de compiler door de null-status van de expressie te wijzigen. Tijdens runtime wordt de expressie x! geëvalueerd naar het resultaat van de onderliggende expressie x.

Zie Null-referentietypen voor meer informatie over de functie voor null-verwijzingstypen.

Voorbeelden

Een van de use cases van de operator null-forgiving is het testen van de argumentvalidatielogica. Denk bijvoorbeeld aan de volgende klasse:

#nullable enable
public class Person
{
    public Person(string name) => Name = name ?? throw new ArgumentNullException(nameof(name));

    public string Name { get; }
}

Met behulp van het MSTest-testframework kunt u de volgende test maken voor de validatielogica in de constructor:

[TestMethod, ExpectedException(typeof(ArgumentNullException))]
public void NullNameShouldThrowTest()
{
    var person = new Person(null!);
}

Zonder de operator null-forgiving genereert de compiler de volgende waarschuwing voor de voorgaande code: Warning CS8625: Cannot convert null literal to non-nullable reference type Met behulp van de operator null-forgiving geeft u de compiler aan dat het doorgeven van null wordt verwacht en dat hier geen waarschuwing voor hoeft te worden gegeven.

U kunt ook de operator null-forgiving gebruiken wanneer u zeker weet dat een expressie niet kan zijn null , maar dat de compiler dat niet kan herkennen. In het volgende voorbeeld, als de IsValid methode true retourneert, is het argument niet null en kunt u het veilig derefereren.

public static void Main()
{
    Person? p = Find("John");
    if (IsValid(p))
    {
        Console.WriteLine($"Found {p!.Name}");
    }
}

public static bool IsValid(Person? person)
    => person is not null && person.Name is not null;

Zonder de operator null-forgiving genereert de compiler de volgende waarschuwing voor de p.Name code: Warning CS8602: Dereference of a possibly null reference

Als u de IsValid methode kunt wijzigen, kunt u het kenmerk NotNullWhen gebruiken om de compiler te informeren dat een argument van de IsValid methode niet kan zijn null wanneer de methode retourneert true:

public static void Main()
{
    Person? p = Find("John");
    if (IsValid(p))
    {
        Console.WriteLine($"Found {p.Name}");
    }
}

public static bool IsValid([NotNullWhen(true)] Person? person)
    => person is not null && person.Name is not null;

In het voorgaande voorbeeld hoeft u de null-vergevingsgezinde operator niet te gebruiken, omdat de compiler voldoende informatie heeft om vast te stellen dat p niet null kan zijn binnen de if-instructie. Zie Upgrade-API's met kenmerken om null-verwachtingen te definiëren voor meer informatie over de null-status van een variabele.

C#-taalspecificatie

Voor meer informatie, zie de sectie null-forgiving-operator van het concept van de specificatie voor null-referentietypen.

Zie ook