Řešení upozornění s možnou hodnotou null

Článek
12/14/2023

Tento článek se zabývá následujícími upozorněními kompilátoru:

Cs8597 - Thrown value may be null.
CS8600 - Converting null literal or possible null value to non-nullable type.
CS8601 - Možné přiřazení odkazu s hodnotou null
CS8602 - Dereference pravděpodobně nulového odkazu.
CS8603 - Možné vrácení nulového odkazu.
CS8604 - Možný argument odkazu null pro parametr.
CS8605 - Unboxing a event null value.
CS8607 - Možnou hodnotu null nelze použít pro typ označený [NotNull] nebo[DisallowNull]
CS8608 - Nullability odkazových typů typu neodpovídá přepsaného členu.
CS8609 - Nullability odkazových typů ve návratového typu neodpovídá přepsaného členu.
CS8610 - Nullability odkazových typů v parametru typu neodpovídá přepsaného členu.
CS8611 - Nullability odkazových typů v parametru typu neodpovídá částečné deklaraci metody.
CS8612 - Nullability odkazových typů typu neodpovídá implicitně implementovanému členu.
CS8613 - Nullability odkazových typů ve návratového typu neodpovídá implicitně implementovanému členu.
CS8614 - Nullability odkazových typů typu parametr neodpovídá implicitně implementovanému členu.
CS8615 - Nullability odkazových typů typu neodpovídá implementovanému členu.
CS8616 - Nullability odkazových typů ve návratového typu neodpovídá implementovanému členu.
CS8617 - Nullability odkazových typů typu parametr neodpovídá implementovanému členu.
Cs8618 - Proměnná bez hodnoty null musí při ukončení konstruktoru obsahovat nenulovou hodnotu. Zvažte jeho deklarování jako nullable.
CS8619 - Nullability odkazových typů v hodnotě neodpovídá cílovému typu.
Argument CS8620 - nelze použít pro parametr kvůli rozdílům v nullability referenčních typů.
CS8621 - Nullability odkazových typů ve návratovém typu neodpovídá cílovému delegátu (pravděpodobně kvůli atributům nullability).
CS8622 - Nullability odkazových typů typu parametru neodpovídá cílovému delegátu (pravděpodobně kvůli atributům nullability).
Argument CS8624 - nelze použít jako výstup kvůli rozdílům v nulové použitelnosti referenčních typů.
CS8625 - Nelze převést literál null na nenulový odkazový typ.
Typ hodnoty CS8629 - s možnou hodnotou null může být null.
CS8631 - Typ nelze použít jako parametr typu v obecném typu nebo metodě. Hodnota Nullability argumentu typu neodpovídá typu omezení.
CS86333 - Nullability v omezeních pro parametr typu metody neodpovídá omezením pro parametr typu metody rozhraní. Místo toho zvažte použití explicitní implementace rozhraní.
CS8634 - Typ nelze použít jako parametr typu v obecném typu nebo metodě. Hodnota Nullability argumentu typu neodpovídá omezení "class".
CS8643 - Nullability odkazových typů ve specifikátoru explicitního rozhraní neodpovídá rozhraní implementovanému typem.
Typ CS8644 - neimplementuje člena rozhraní. Nulová možnost odkazových typů v rozhraní implementovaném základním typem se neshoduje.
CS8645 - Člen je již uveden v seznamu rozhraní typu s různými nulovými odkazovými typy.
CS8655 - Výraz přepínače nezpracuje některé vstupy null (není vyčerpávající).
Deklarace částečné metody CS8667 - mají nekonzistentní nulovou hodnotu v omezeních parametru typu.
CS8670 - Objekt nebo inicializátor kolekce implicitně dereferences pravděpodobně null člen.
CS8714 - Typ nelze použít jako parametr typu v obecném typu nebo metodě. Hodnota Nullability argumentu typu neodpovídá omezení notnull.
Parametr CS8762 - musí mít při ukončení hodnotu, která nemá hodnotu null.
Metoda CS8763 - A by [DoesNotReturn] neměla vrátit.
CS8764 - Nullability návratového typu neodpovídá přepsaného členu (pravděpodobně kvůli atributům nullability).
CS8765 - Nullability typu parametru neodpovídá přepsaného členu (pravděpodobně kvůli atributům nullability).
CS8766 - Nullability odkazových typů ve návratového typu neodpovídá implicitně implementovanému členu (pravděpodobně kvůli atributům nullability).
CS8767 - Nullability odkazových typů v typu parametru neodpovídá implicitně implementovanému členu (pravděpodobně kvůli atributům nullability).
CS8768 - Nullability odkazových typů ve návratového typu neodpovídá implementovanému členu (pravděpodobně kvůli atributům nullability).
CS8769 - Nullability odkazových typů v typu parametru neodpovídá implementovanému členu (pravděpodobně kvůli atributům nullability).
CS8770 - Metoda nemá poznámky [DoesNotReturn] odpovídající implementovanému nebo přepisovanému členu.
CS8774 - Člen musí mít při ukončení hodnotu, která nemá hodnotu null.
Člen CS8776 - nelze použít v tomto atributu.
CS8775 - Člen musí mít při ukončení hodnotu, která nemá hodnotu null.
Parametr CS8777 - musí mít při ukončení hodnotu, která nemá hodnotu null.
CS8819 - Nullability odkazových typů v návratového typu neodpovídá částečné deklaraci metody.
Parametr CS8824 - musí mít při ukončení hodnotu, která nemá hodnotu null, protože parametr nemá hodnotu null.
Návratová hodnota CS8825 - musí být nenulová, protože parametr nemá hodnotu null.
CS8847 - Výraz přepínače nezpracuje některé vstupy null (není vyčerpávající). Vzor s klauzulí when se však může úspěšně shodovat s touto hodnotou.

Účelem upozornění s možnou hodnotou null je minimalizovat pravděpodobnost, že aplikace při spuštění vyvolá System.NullReferenceException výjimku. K dosažení tohoto cíle kompilátor používá statickou analýzu a zobrazí upozornění, když váš kód obsahuje konstrukty, které můžou vést k výjimkám nulového odkazu. Kompilátoru poskytnete informace pro jeho statickou analýzu použitím poznámek a atributů typu. Tyto poznámky a atributy popisují hodnotu nullability argumentů, parametrů a členů vašich typů. V tomto článku se naučíte různé techniky, jak řešit upozornění s možnou hodnotou null, která kompilátor generuje ze statické analýzy. Zde popsané techniky jsou určené pro obecný kód jazyka C#. Naučte se pracovat s odkazovými typy s možnou hodnotou null a jádrem Entity Framework při práci s odkazovými typy s možnou hodnotou null.

Téměř všechna upozornění budete řešit pomocí jedné ze čtyř technik:

Přidání nezbytných kontrol null
Přidávání ? poznámek s možnou hodnotou null.!
Přidání atributů, které popisují sémantiku null
Inicializace proměnných správně.

Možné dereference hodnoty null

Tato sada upozornění vás upozorní, že dereferencujete proměnnou, jejíž stav null je možná null. Tato upozornění jsou:

CS8602 - Dereference pravděpodobně nulového odkazu.
CS8670 - Objekt nebo inicializátor kolekce implicitně dereferences pravděpodobně null člen.

Následující kód ukazuje jeden příklad každého z předchozích upozornění:

class Container
{
    public List<string>? States { get; set; }
}

internal void PossibleDereferenceNullExamples(string? message)
{
    Console.WriteLine(message.Length); // CS8602

    var c = new Container { States = { "Red", "Yellow", "Green" } }; // CS8670
}

V předchozím příkladu je upozornění důvodem, že Container, , cmůže mít hodnotu null pro States vlastnost. Přiřazení nových stavů ke kolekci, která může mít hodnotu null, způsobí upozornění.

Pokud chcete tato upozornění odebrat, je potřeba přidat kód, který změní stav null této proměnné na hodnotu not-null, než ji přeloží. Upozornění inicializátoru kolekce může být obtížnější zjistit. Kompilátor zjistí, že kolekce možná null při inicializátoru přidá elementy.

V mnoha případech můžete tato upozornění opravit tak, že před jeho zrušením zkontrolujete, že proměnná nemá hodnotu null. Před zrušením odvozování parametru message zvažte následující:

void WriteMessageLength(string? message)
{
    if (message is not null)
    {
        Console.WriteLine(message.Length);
    }
    
}

Následující příklad inicializuje záložní úložiště pro States objekt a odebere set příslušenství. Příjemci třídy mohou upravovat obsah kolekce a úložiště pro kolekci není nikdy null:

class Container
{
    public List<string> States { get; } = new();
}

Jiné instance, když se zobrazí tato upozornění, můžou být falešně pozitivní. Možná máte privátní metodu nástroje, která testuje hodnotu null. Kompilátor neví, že metoda poskytuje kontrolu null. Představte si následující příklad, který používá privátní metodu utility: IsNotNull

public void WriteMessage(string? message)
{
    if (IsNotNull(message))
        Console.WriteLine(message.Length);
}

Kompilátor varuje, že při zápisu vlastnosti message.Length může být dereferencing null, protože jeho statická analýza určuje, že message může být null. Je možné, že víte, že IsNotNull poskytuje kontrolu null, a když se vrátí true, stav null message by neměl být null. Kompilátoru musíte sdělit tato fakta. Jedním zezpůsobůch ! Příkaz můžete změnit WriteLine tak, aby odpovídal následujícímu kódu:

Console.WriteLine(message!.Length);

Operátor pro zrušení hodnoty null způsobí, že výraz není null , i když byl možná null bez ! použití. V tomto příkladu je lepším řešením přidat atribut k podpisu IsNotNull:

private static bool IsNotNull([NotNullWhen(true)] object? obj) => obj != null;

Informuje System.Diagnostics.CodeAnalysis.NotNullWhenAttribute kompilátor, že argument použitý pro obj parametr není-null, když metoda vrátí true. Když metoda vrátí false, argument má stejný stav null, který měl předtím, než byla volána metoda.

Tip

Existuje bohatá sada atributů, které můžete použít k popisu, jak vaše metody a vlastnosti ovlivňují stav null. O nich se můžete dozvědět v článku s referenčními informacemi o atributech statické analýzy s možnou hodnotou Null.

Oprava upozornění pro dereferencování proměnné typu možná null zahrnuje jednu ze tří technik:

Přidejte chybějící kontrolu null.
Přidejte atributy analýzy null v rozhraních API, které mají vliv na statickou analýzu stavu null kompilátoru. Tyto atributy informují kompilátor, pokud by návratová hodnota nebo argument měl být možná null nebo not-null po volání metody.
Použití operátoru ! odpustit hodnotu null u výrazu k vynucení stavu na hodnotu not-null.

Možnou hodnotu null přiřazenou nenulovatelnému odkazu

Tato sada upozornění vás upozorní, že přiřazujete proměnnou, jejíž typ je nenulovatelný výrazu, jehož stav null je možná null. Tato upozornění jsou:

Cs8597 - Thrown value may be null.
CS8600 - Converting null literal or possible null value to non-nullable type.
CS8601 - Možné přiřazení odkazu s hodnotou null
CS8603 - Možné vrácení nulového odkazu.
CS8604 - Možný argument odkazu null pro parametr.
CS8605 - Unboxing a event null value.
CS8625 - Nelze převést literál null na nenulový odkazový typ.
Typ hodnoty CS8629 - s možnou hodnotou null může být null.

Kompilátor vygeneruje tato upozornění při pokusu o přiřazení výrazu, který je možná null proměnné, která není nenulovatelná. Příklad:

string? TryGetMessage(int id) => "";

string msg = TryGetMessage(42);  // Possible null assignment.

Různá upozornění obsahují podrobnosti o kódu, jako je přiřazení, zrušení přiřazení, návratové příkazy, argumenty metod a vyvolání výrazů.

Pokud chcete tato upozornění vyřešit, můžete provést jednu ze tří akcí. Jedním z nich je přidání poznámky ? , aby proměnná byla typu odkazu s možnou hodnotou null. Tato změna může způsobit další upozornění. Změna proměnné z nenulového odkazu na odkaz s možnou hodnotou null změní výchozí stav null z hodnoty not-null na hodnotu null. Statická analýza kompilátoru může najít instance, ve kterých se dereference proměnné, která je možná null.

Ostatní akce instruují kompilátoru, že pravá strana přiřazení není null. Výraz na pravé straně může být před přiřazením označený hodnotou null, jak je znázorněno v následujícím příkladu:

string notNullMsg = TryGetMessage(42) ?? "Unknown message id: 42";

Předchozí příklady ukazují přiřazení návratové hodnoty metody. Můžete anotovat metodu (nebo vlastnost), která označuje, kdy metoda vrátí hodnotu not-null. Často System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute určuje, že návratová hodnota není null , pokud vstupní argument není null. Další alternativou je přidání operátoru ! pro odpouštění null na pravou stranu:

string msg = TryGetMessage(42)!;

Oprava upozornění pro přiřazení výrazu typu možná null proměnné not-null zahrnuje jednu ze čtyř technik:

Změňte levou stranu přiřazení na typ s možnou hodnotou null. Tato akce může při dereferenci této proměnné zavést nová upozornění.
Před přiřazením zadejte kontrolu hodnoty null.
Anotujte rozhraní API, které vytváří pravou stranu přiřazení.
Na pravou stranu přiřazení přidejte operátor pro odřazování null.

Nenulovatelný odkaz není inicializován

Tato sada upozornění vás upozorní, že přiřazujete proměnnou, jejíž typ nemá hodnotu null, výrazu, jehož stav null je možná null. Tato upozornění jsou:

Cs8618 - Proměnná bez hodnoty null musí při ukončení konstruktoru obsahovat nenulovou hodnotu. Zvažte jeho deklarování jako nullable.
Parametr CS8762 - musí mít při ukončení hodnotu, která nemá hodnotu null.

Jako příklad vezměte v úvahu následující třídu:

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

LastName Ani FirstName nejsou zaručeny inicializovány. Pokud je tento kód nový, zvažte změnu veřejného rozhraní. Výše uvedený příklad lze aktualizovat následujícím způsobem:

public class Person
{
    public Person(string first, string last)
    {
        FirstName = first;
        LastName = last;
    }

    public string FirstName { get; set; }
    public string LastName { get; set; }
}

Pokud před nastavením názvu požadujete vytvoření objektu Person , můžete vlastnosti inicializovat pomocí výchozí hodnoty, která není null:

public class Person
{
    public string FirstName { get; set; } = string.Empty;
    public string LastName { get; set; } = string.Empty;
}

Další alternativou může být změna těchto členů na odkazové typy s možnou hodnotou null. Třída Person by mohla být definována následujícím způsobem, pokud null by měla být pro název povolena:

public class Person
{
    public string? FirstName { get; set; }
    public string? LastName { get; set; }
}

Existující kód může vyžadovat další změny, aby kompilátor informoval o sémantice null pro tyto členy. Možná jste vytvořili více konstruktorů a vaše třída může mít soukromou pomocnou metodu, která inicializuje jeden nebo více členů. Inicializační kód můžete přesunout do jednoho konstruktoru a zajistit, aby všechny konstruktory volaly ten s běžným inicializačním kódem. Nebo můžete použít System.Diagnostics.CodeAnalysis.MemberNotNullAttribute atributy.System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute Tyto atributy informují kompilátor, že člen není null po zavolání metody. Následující kód ukazuje příklad každého z nich. Třída Person používá společný konstruktor volaný všemi ostatními konstruktory. Třída Student má pomocnou metodu anotovanou atributem System.Diagnostics.CodeAnalysis.MemberNotNullAttribute :


using System.Diagnostics.CodeAnalysis;

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }

    public Person() : this("John", "Doe") { }
}

public class Student : Person
{
    public string Major { get; set; }

    public Student(string firstName, string lastName, string major)
        : base(firstName, lastName)
    {
        SetMajor(major);
    }

    public Student(string firstName, string lastName) :
        base(firstName, lastName)
    {
        SetMajor();
    }

    public Student()
    {
        SetMajor();
    }

    [MemberNotNull(nameof(Major))]
    private void SetMajor(string? major = default)
    {
        Major = major ?? "Undeclared";
    }
}

Nakonec můžete pomocí operátoru odgiving null označit, že člen je inicializován v jiném kódu. V jiném příkladu zvažte následující třídy představující model Entity Framework Core:

public class TodoItem
{
    public long Id { get; set; }
    public string? Name { get; set; }
    public bool IsComplete { get; set; }
}

public class TodoContext : DbContext
{
    public TodoContext(DbContextOptions<TodoContext> options)
        : base(options)
    {
    }

    public DbSet<TodoItem> TodoItems { get; set; } = null!;
}

Vlastnost DbSet je inicializována na null!. To říká kompilátoru, že vlastnost je nastavena na hodnotu not-null . Ve skutečnosti základ DbContext provádí inicializaci sady. Statická analýza kompilátoru to nezachytá. Další informace o práci s odkazovými typy s možnou hodnotou null a Entity Framework Core najdete v článku Práce s odkazovými typy s možnou hodnotou Null v EF Core.

Oprava upozornění pro inicializaci nenulovatelného členu zahrnuje jednu ze čtyř technik:

Změňte konstruktory nebo inicializátory polí, aby se zajistilo, že jsou inicializovány všechny nenulovatelné členy.
Změňte jeden nebo více členů na typy s možnou hodnotou null.
Označte všechny pomocné metody poznámkami, které označují, které členy jsou přiřazeny.
Přidejte inicializátor, který null! inicializuje člen v jiném kódu.

Neshoda v deklaraci použitelnosti s hodnotou null

Mnoho upozornění indikuje neshodu s hodnotou null mezi podpisy pro metody, delegáty nebo parametry typu.

CS8608 - Nullability odkazových typů typu neodpovídá přepsaného členu.
CS8609 - Nullability odkazových typů ve návratového typu neodpovídá přepsaného členu.
CS8610 - Nullability odkazových typů v parametru typu neodpovídá přepsaného členu.
CS8611 - Nullability odkazových typů v parametru typu neodpovídá částečné deklaraci metody.
CS8612 - Nullability odkazových typů typu neodpovídá implicitně implementovanému členu.
CS8613 - Nullability odkazových typů ve návratového typu neodpovídá implicitně implementovanému členu.
CS8614 - Nullability odkazových typů typu parametr neodpovídá implicitně implementovanému členu.
CS8615 - Nullability odkazových typů typu neodpovídá implementovanému členu.
CS8616 - Nullability odkazových typů ve návratového typu neodpovídá implementovanému členu.
CS8617 - Nullability odkazových typů typu parametr neodpovídá implementovanému členu.
CS8619 - Nullability odkazových typů v hodnotě neodpovídá cílovému typu.
Argument CS8620 - nelze použít pro parametr kvůli rozdílům v nullability referenčních typů.
CS8621 - Nullability odkazových typů ve návratovém typu neodpovídá cílovému delegátu (pravděpodobně kvůli atributům nullability).
CS8622 - Nullability odkazových typů typu parametru neodpovídá cílovému delegátu (pravděpodobně kvůli atributům nullability).
Argument CS8624 - nelze použít jako výstup kvůli rozdílům v nulové použitelnosti referenčních typů.
CS8631 - Typ nelze použít jako parametr typu v obecném typu nebo metodě. Hodnota Nullability argumentu typu neodpovídá typu omezení.
CS86333 - Nullability v omezeních pro parametr typu metody neodpovídá omezením pro parametr typu metody rozhraní. Místo toho zvažte použití explicitní implementace rozhraní.
CS8634 - Typ nelze použít jako parametr typu v obecném typu nebo metodě. Hodnota Nullability argumentu typu neodpovídá omezení "class".
CS8643 - Nullability odkazových typů ve specifikátoru explicitního rozhraní neodpovídá rozhraní implementovanému typem.
Typ CS8644 - neimplementuje člena rozhraní. Nulová možnost odkazových typů v rozhraní implementovaném základním typem se neshoduje.
CS8645 - Člen je již uveden v seznamu rozhraní typu s různými nulovými odkazovými typy.
Deklarace částečné metody CS8667 - mají nekonzistentní nulovou hodnotu v omezeních parametru typu.
CS8714 - Typ nelze použít jako parametr typu v obecném typu nebo metodě. Hodnota Nullability argumentu typu neodpovídá omezení notnull.
CS8764 - Nullability návratového typu neodpovídá přepsaného členu (pravděpodobně kvůli atributům nullability).
CS8765 - Nullability typu parametru neodpovídá přepsaného členu (pravděpodobně kvůli atributům nullability).
CS8766 - Nullability odkazových typů ve návratového typu neodpovídá implicitně implementovanému členu (pravděpodobně kvůli atributům nullability).
CS8767 - Nullability odkazových typů v typu parametru neodpovídá implicitně implementovanému členu (pravděpodobně kvůli atributům nullability).
CS8768 - Nullability odkazových typů ve návratového typu neodpovídá implementovanému členu (pravděpodobně kvůli atributům nullability).
CS8769 - Nullability odkazových typů v typu parametru neodpovídá implementovanému členu (pravděpodobně kvůli atributům nullability).
CS8819 - Nullability odkazových typů v návratového typu neodpovídá částečné deklaraci metody.

Následující kód ukazuje CS8764:

public class B
{
    public virtual string GetMessage(string id) => string.Empty;
}
public class D : B
{
    public override string? GetMessage(string? id) => default;
}

Předchozí příklad ukazuje metodu virtual v základní třídě a s jinou override nullability. Základní třída vrátí řetězec, který není nullable, ale odvozená třída vrátí řetězec s možnou hodnotou null. Pokud jsou string a string? jsou obráceny, bylo by povoleno, protože odvozená třída je více omezující. Podobně by se deklarace parametrů měly shodovat. Parametry v metodě přepsání mohou povolit hodnotu null i v případě, že základní třída ne.

Tato upozornění můžou vygenerovat i další situace. V deklaraci metody rozhraní a implementaci této metody může dojít k neshodě. Nebo typ delegáta a výraz pro daného delegáta se může lišit. Parametr typu a argument typu se můžou lišit v hodnotě null.

Chcete-li tato upozornění opravit, aktualizujte příslušnou deklaraci.

Kód neodpovídá deklaraci atributu

V předchozích částech jsme probrali, jak můžete použít atributy pro statickou analýzu s možnou hodnotou null k informování kompilátoru o sémantice null vašeho kódu. Kompilátor vás upozorní, pokud kód nedodržuje přísliby tohoto atributu:

CS8607 - Možnou hodnotu null nelze použít pro typ označený [NotNull] nebo[DisallowNull]
Metoda CS8763 - A by [DoesNotReturn] neměla vrátit.
CS8770 - Metoda nemá poznámky [DoesNotReturn] odpovídající implementovanému nebo přepisovanému členu.
CS8774 - Člen musí mít při ukončení hodnotu, která nemá hodnotu null.
CS8775 - Člen musí mít při ukončení hodnotu, která nemá hodnotu null.
Člen CS8776 - nelze použít v tomto atributu.
Parametr CS8777 - musí mít při ukončení hodnotu, která nemá hodnotu null.
Parametr CS8824 - musí mít při ukončení hodnotu, která nemá hodnotu null, protože parametr nemá hodnotu null.
Návratová hodnota CS8825 - musí být nenulová, protože parametr nemá hodnotu null.

Zvažte následující metodu:

public bool TryGetMessage(int id, [NotNullWhen(true)] out string? message)
{
    message = null;
    return true;

}

Kompilátor vytvoří upozornění, protože message parametr je přiřazen null a metoda vrátí true. Atribut NotNullWhen označuje, že by se nemělo stát.

Pokud chcete tato upozornění vyřešit, aktualizujte kód tak, aby odpovídal očekáváním atributů, které jste použili. Můžete změnit atributy nebo algoritmus.

Vyčerpávající výraz přepínače

Výrazy přepínače musí být vyčerpávající, což znamená, že všechny vstupní hodnoty musí být zpracovány. I pro odkazové typy, které nemají hodnotu null, null musí být tato hodnota rovna. Kompilátor vydává upozornění, když není zpracována hodnota null:

CS8655 - Výraz přepínače nezpracuje některé vstupy null (není vyčerpávající).
CS8847 - Výraz přepínače nezpracuje některé vstupy null (není vyčerpávající). Vzor s klauzulí when se však může úspěšně shodovat s touto hodnotou.

Následující příklad kódu ukazuje tuto podmínku:

int AsScale(string status) =>
    status switch
    {
        "Red" => 0,
        "Yellow" => 5,
        "Green" => 10,
        { } => -1
    };

Vstupní výraz je , stringnikoli string?. Kompilátor toto upozornění přesto vygeneruje. Vzor { } zpracovává všechny hodnoty, které nejsou null, ale neodpovídají null. Pokud chcete tyto chyby vyřešit, můžete buď přidat explicitní null případ, nebo nahradit { } vzorem _ (zahodit). Vzor zahození odpovídá hodnotě null i jakékoli jiné hodnotě.

Sdílet prostřednictvím