Dela via

! Operatorn null-förlåtande (C#-referens)

Den unära postfixoperatorn ! är den null-forgiving, eller null-suppression, operatorn. I en aktiverad nullbar anteckningskontext använder du operatorn null-forgiving för att ignorera alla nullbara varningar för föregående uttryck. Operatorn unary prefix ! är den logiska negationsoperatorn. Operatorn för att bortse från null har ingen effekt vid körning. Det påverkar bara kompilatorns statiska flödesanalys genom att ändra null-tillståndet för uttrycket. Vid körning utvärderas uttrycket x! till resultatet av det underliggande uttrycket x.

Mer information om funktionen för nullable referenstyper finns i Nullable referenstyper.

C#-språkreferensen dokumenterar den senaste versionen av C#-språket. Den innehåller även inledande dokumentation för funktioner i offentliga förhandsversioner för den kommande språkversionen.

Dokumentationen identifierar alla funktioner som först introducerades i de tre senaste versionerna av språket eller i aktuella offentliga förhandsversioner.

Tips/Råd

Information om när en funktion först introducerades i C# finns i artikeln om språkversionshistoriken för C#.

Exempel

Ett användningsfall för operatorn null-forgiving är att testa argumentvalideringslogik. Tänk till exempel på följande klass:

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

    public string Name { get; }
}

Genom att använda MSTest-testramverket kan du skapa följande test för valideringslogik i konstruktorn:

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

Utan operatorn null-forgiving genererar kompilatorn följande varning för föregående kod: Warning CS8625: Cannot convert null literal to non-nullable reference type. Genom att använda operatorn null-forgiving informerar du kompilatorn om att överföring null förväntas och inte bör generera en varning.

Du kan också använda operatorn null-forgiving när du definitivt vet att ett uttryck inte kan vara null men kompilatorn inte känner igen det. I följande exempel, om metoden IsValid returnerar true, är dess argument inte null och du kan säkert avreferera den.

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;

Utan operatorn null-forgiving genererar kompilatorn följande varning för p.Name koden: Warning CS8602: Dereference of a possibly null reference.

Om du kan ändra IsValid metoden kan du använda attributet NotNullWhen för att informera kompilatorn om att ett argument för IsValid metoden inte kan vara null när metoden returnerar 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;

I föregående exempel behöver du inte använda operatorn null-forgiving eftersom kompilatorn har tillräckligt med information för att ta reda på att p inte kan vara null inuti instruktionen if. Mer information om de attribut som gör att du kan ange ytterligare information om null-tillståndet för en variabel finns i Uppgradera API:er med attribut för att definiera null-förväntningar.

Språkspecifikation för C#

Mer information finns i avsnittet om null-förlåtande operatorn i utkastet till specifikationen för nullable referenstyper.

Se även

  • Last updated on