Dela via

! Operatorn (null-forgiving) (C#-referens)

  • Artikel

Operatorn unary postfix ! är operatorn null-forgiving, eller null-suppression. I en aktiverad nullbar anteckningskontext använder du operatorn null-forgiving för att ignorera alla null-varningar för föregående uttryck. Operatorn unary prefix ! är den logiska negationsoperatorn. Operatorn null-forgiving 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 null-referenstyper finns i Referenstyper som kan ogiltigförklaras.

Exempel

Ett av användningsfallen 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; }
}

Med hjälp av 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 varnas för.

Du kan också använda operatorn null-forgiving när du definitivt vet att ett uttryck inte kan vara null men kompilatorn inte lyckas känna igen det. I följande exempel, om IsValid metoden returnerar true, är dess argument inte null och du kan på ett säkert sätt avreferering av 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 det inte kan finnas null i -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 null-förlåtande operator i utkastet till specifikationen för null-referenstyper.

Se även