Delen via

Null-waarschuwingen oplossen

  • Artikel

Het doel van null-waarschuwingen is om de kans te minimaliseren dat uw toepassing een System.NullReferenceException-fout veroorzaakt wanneer deze wordt uitgevoerd. Om dit doel te bereiken, gebruikt de compiler statische analyse en waarschuwingen voor problemen wanneer uw code constructies heeft die kunnen leiden tot null-referentie-uitzonderingen. U geeft de compiler informatie over de statische analyse door typeaantekeningen en -kenmerken toe te passen. Deze aantekeningen en kenmerken beschrijven de null-waarde van argumenten, parameters en leden van uw typen. In dit artikel leert u verschillende technieken om om te gaan met de nulwaardenwaarschuwingen die de compiler genereert op basis van de statische analyse. De technieken die hier worden beschreven, zijn voor algemene C#-code. Leer hoe u kunt werken met null-referentietypen en Entity Framework-kern in Werken met null-referentietypen.

Nullbare verwijzingstypen, inclusief de operatoren ? en !, zijn alleen toegestaan wanneer de nullbare context is ingesteld op enable of annotations. U kunt de null-context instellen met behulp van de Nullablecompileroptie in uw projectbestand of met behulp van de #nullable pragma in uw broncode.

In dit artikel worden de volgende compilerwaarschuwingen behandeld:

  • CS8597 - Opgeworpen waarde kan null zijn.
  • CS8598 - De onderdrukkingsoperator is niet toegestaan in deze context
  • CS8600 - Nul-letterlijke waarde of mogelijke nul-waarde converteren naar een niet-nul-type.
  • CS8601 - Mogelijke toewijzing van een null-verwijzing.
  • CS8602 - Dereference van een mogelijk null-verwijzing.
  • CS8603 - Mogelijke null-verwijzing wordt geretourneerd.
  • CS8604 - Mogelijk null-verwijzingsargument voor parameter.
  • CS8605 - Een mogelijk null-waarde uitpakken.
  • CS8607 - Een mogelijke null-waarde kan niet worden gebruikt voor een type dat is gemarkeerd met [NotNull] of [DisallowNull]
  • CS8608 - Nullability van referentietypes in type komt niet overeen met het lid dat het overschrijft.
  • CS8609 - Nullabiliteit van verwijzingstypen in het retourtype komt niet overeen met het overschreven lid.
  • CS8610 - De nullabiliteit van referentietypen in het typeparameter komt niet overeen met het overschreven lid.
  • CS8611 - Nullabiliteit van referentietypen in typeparameter komt niet overeen met gedeeltelijke methodedeclaratie.
  • CS8612 - Nullbaarheid van referentietypes in type komt niet overeen met impliciet geïmplementeerd lid.
  • CS8613 - De nullability van referentietypen in het retourneertype komt niet overeen met het impliciet geïmplementeerde lid.
  • CS8614 - Null-waarde van referentietypen in type van parameter komt niet overeen met impliciet geïmplementeerd lid.
  • CS8615 - Nullbaarheid van referentietypes in type komt niet overeen met lid van de implementatie.
  • CS8616 - De nullbaarheid van referentietypen in het retourtype komt niet overeen met het geïmplementeerde onderdeel.
  • CS8617 - De nullbaarheid van verwijzingstypen in het type van de parameter komt niet overeen met het geïmplementeerde lid.
  • CS8618 - Niet-nulleerbare variabele moet een niet-nulleerbare waarde bevatten bij het verlaten van de constructor. Overweeg deze te declareren als nulleerbaar.
  • CS8619 - De nullbaarheid van referentietypen in de waarde komt niet overeen met het doeltype.
  • CS8620 - Argument kan niet worden gebruikt voor de parameter vanwege verschillen in de nullbaarheid van verwijzingstypen.
  • CS8621 - Onbepaaldheid van referentietypen in de retourwaarde komt niet overeen met de doeldelegee (mogelijk vanwege nullability-attributen).
  • CS8622 - Nullability of reference types in type parameter komt niet overeen met de doeldelegatie (mogelijk vanwege nullability attributes).
  • CS8623 - Expliciete toepassing van System.Runtime.CompilerServices.NullableAttribute is niet toegestaan.
  • CS8624 - Argument kan niet worden gebruikt als uitvoer door verschillen in de nullwaardigheid van verwijzingstypen.
  • CS8625 - Kan null niet converteren naar niet-nullbare verwijzingstype.
  • CS8628 - Kan geen null-verwijzingstype gebruiken bij het maken van objecten.
  • CS8629 - Nullable waardetype kan een nulwaarde zijn.
  • CS8631 - Het type kan niet worden gebruikt als typeparameter in het generieke type of de methode. Nullabiliteit van het typeargument komt niet overeen met het limitatietype.
  • CS8632 - De aantekening voor null-referentietypen mag alleen worden gebruikt in code binnen een context van #nullable aantekeningen.
  • CS8633 - Nullability in beperkingen voor de typeparameter van de methode komt niet overeen met de beperkingen voor de typeparameter van de interfacemethode. Overweeg een expliciete interface-implementatie te gebruiken.
  • CS8634 - Het type kan niet worden gebruikt als type parameter in het generieke type of de generieke methode. Nullbaarheid van het typeargument komt niet overeen met de beperking 'klasse'.
  • cs8636 - ongeldige optie voor /nullable; moet disable, enable, warnings of annotations zijn
  • CS8637 - Verwacht enable, disableof restore
  • CS8639 - De typeof-operator kan niet worden gebruikt voor een null-verwijzingstype
  • CS8643 - Nullability van verwijzingstypen in expliciete interface-specificatie komt niet overeen met de interface die door het type is geïmplementeerd.
  • CS8644 - Type implementeert geen interfacelid. De nullbaarheid van referentietypen in de interface die door het basistype wordt geïmplementeerd, komt niet overeen.
  • CS8645 - Lid wordt al vermeld in de interfacelijst op type met verschillende null-waarde van referentietypen.
  • CS8655 - De switchexpressie verwerkt geen null-invoer (dit is niet volledig).
  • CS8667 - Gedeeltelijke methodedeclaraties hebben inconsistente nullbaarheid in beperkingen voor typeparameter.
  • CS8670 - Object- of verzamelingsinitialisator verwijst impliciet naar mogelijk null-lid.
  • CS8714 - Het type kan niet worden gebruikt als typeparameter in het algemene type of de methode. De null-waarde van het typeargument komt niet overeen met de beperking 'notnull'.
  • CS8762 - Parameter moet een niet-nul-waarde hebben bij het afsluiten.
  • CS8763 - Een methode die is gemarkeerd[DoesNotReturn], mag niet worden geretourneerd.
  • CS8764 - Nullbaarheid van het retourneertype komt niet overeen met het overschreven lid (mogelijk vanwege nullbaarheidsattributen).
  • CS8765 - Nullability van het type parameter komt niet overeen met het overschreven lid (mogelijk vanwege nullability-kenmerken).
  • CS8766 - De nullability van referentietypen in het retourtype komt niet overeen met het impliciet geïmplementeerde lid (mogelijk vanwege nullabiliteitsattributen).
  • CS8767 - Nullability van referentietypen in type van parameter komt niet overeen met impliciet geïmplementeerd lid (mogelijk door nullability-attributen).
  • CS8768 - De nullabiliteit van referentietypen in het retourtype komt niet overeen met het geïmplementeerde lid (mogelijk vanwege nullability-attributen).
  • CS8769 - Nullability of reference types in type parameter komt niet overeen met geïmplementeerd lid (mogelijk vanwege nullability attributes).
  • CS8770 - Methode mist [DoesNotReturn] annotatie om overeen te komen met geïmplementeerd of overschreven lid.
  • CS8774 - Het lid moet een niet-null-waarde hebben bij het afsluiten.
  • CS8776 - Lid kan niet worden gebruikt in dit kenmerk.
  • CS8775-lid - moet een niet-null-waarde hebben bij het verlaten.
  • De parameter CS8777 - moet een niet-null-waarde hebben bij het afsluiten.
  • CS8819 - De nullbaarheid van referentietypen in het retourneertype komt niet overeen met de declaratie van de gedeeltelijke methode.
  • CS8824 - De parameter moet een niet-null-waarde hebben bij het verlaten omdat de parameter niet null is.
  • CS8825 - De retourwaarde moet niet-nul zijn omdat de parameter niet-nul is.
  • CS8847 - De switchexpressie verwerkt geen enkele null-invoer (dit is niet volledig). Een patroon met een 'when'-component kan echter overeenkomen met deze waarde.

Notitie

De statische analyse kan niet altijd afleiden in welke volgorde, in een specifiek scenario, methoden worden geopend en of de methode is voltooid zonder een uitzondering te genereren. Deze bekende valkuilen worden goed beschreven in Bekende valkuilen sectie.

U kunt bijna alle waarschuwingen aanpakken met behulp van een van de vijf technieken:

  • De nullbare context configureren.
  • Noodzakelijke null-controles toevoegen.
  • Toevoegen of verwijderen van ? of ! nullbare annotaties.
  • Kenmerken toevoegen die null-semantiek beschrijven.
  • Variabelen correct initialiseren.

Als u geen gebruik hebt gemaakt van null-verwijzingstypen, biedt het overzicht van null-referentietypen een achtergrond over wat nullable-verwijzingstypen oplossen en hoe ze waarschuwingen bieden voor mogelijke fouten in uw code. U kunt ook de richtlijnen raadplegen over migreren naar nullable-referentietypen om meer te leren over het inschakelen van nullable-referentietypen in een bestaand project.

Null-context configureren

De volgende waarschuwingen geven aan dat u de nullable context niet juist hebt ingesteld:

  • CS8632 - De aantekening voor null-verwijzingstypen mag alleen worden gebruikt in code binnen een context van #nullable aantekeningen.
  • cs8636 - ongeldige optie voor /nullable; moet disable, enable, warnings of annotations zijn
  • CS8637 - Verwachte enable, disableof restore

Onjuiste aantekeningsyntaxis

Deze fouten en waarschuwingen geven aan dat het gebruik van de ! of ? aantekening onjuist is.

  • CS8598 - De onderdrukkingsoperator is niet toegestaan in deze context
  • CS8623 - Expliciete toepassing van System.Runtime.CompilerServices.NullableAttribute is niet toegestaan.
  • CS8628 - Kan geen null-verwijzingstype gebruiken bij het maken van objecten.
  • CS8639 - De typeof-operator kan niet worden gebruikt voor een null-verwijzingstype

De ? aantekening in een declaratie geeft aan dat de variabele mogelijk null is. Er wordt geen ander runtimetype aangegeven. Beide declaraties zijn hetzelfde runtimetype:

string s1 = "a string";
string? s2 = "another string";

De ? is een hint voor de compiler op basis van de verwachting voor null-waarden.

De ! aantekening in een expressie geeft aan dat u weet dat de expressie veilig is en moet worden aangenomen dat deze niet null is.

  • U moet deze aantekeningen gebruiken, niet de System.Runtime.CompilerServices.NullableAttribute in uw code.
  • Omdat het ? een aantekening is, geen type, kunt u deze niet gebruiken met typeofof new expressies.
  • De operator ! kan niet worden toegepast op een variabeleexpressie of een methodegroep.
  • De operator ! kan niet links van een operator voor lidtoegang worden toegepast, zoals obj.Field!.Method().

Mogelijk derefereren van null

Deze reeks waarschuwingen informeert u dat u een variabele dereferentieert waarvan de null-toestand mogelijk null kan zijn. Deze waarschuwingen zijn:

  • CS8602 - Het derefereren van een mogelijke nul-verwijzing.
  • CS8670 - Object- of verzamelingsinitializer derefereert mogelijk nul-lid impliciet.

In de volgende code ziet u een voorbeeld van elk van de voorgaande waarschuwingen:

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
}

In het voorgaande voorbeeld is er een waarschuwing omdat de Containeren cmogelijk een null-waarde voor de eigenschap States hebben. Als u nieuwe statussen toewijst aan een verzameling die mogelijk null is, wordt de waarschuwing veroorzaakt.

Als u deze waarschuwingen wilt verwijderen, moet u code toevoegen om de null-status van die variabele te wijzigen naar not-null voordat u deze dereferentie uitvoert. De waarschuwing voor het initialiseren van verzamelingen kan moeilijker te herkennen zijn. De compiler detecteert dat de verzameling misschien null is wanneer de initialisatiefunctie er elementen aan toevoegt.

In veel gevallen kunt u deze waarschuwingen oplossen door te controleren of een variabele niet null is voordat u deze dereferenceert. Bekijk het volgende voorbeeld waarin een null-controle wordt toegevoegd voordat de parameter message wordt gedereferenceerd.

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

In het volgende voorbeeld wordt de opslag voor de States geïnitialiseerd en wordt de set toegangsfunctie verwijderd. Consumenten van de klasse kunnen de inhoud van de verzameling wijzigen en de opslag voor de verzameling is nooit null:

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

Andere gevallen waarin u deze waarschuwingen krijgt, kunnen vals-positieven zijn. Mogelijk hebt u een privé hulpprogrammamethode die null test. De compiler weet niet dat de methode een null-controle biedt. Bekijk het volgende voorbeeld waarin gebruik wordt gemaakt van een privé-hulpmethode: IsNotNull

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

De compiler waarschuwt dat u mogelijk een null dereferentie maakt wanneer u de eigenschap message.Length schrijft, omdat de statische analyse bepaalt dat message mogelijk nullis. U weet dat IsNotNull een null-controle biedt en wanneer deze trueretourneert, moet de null-status van messageniet-null-zijn. U moet de compiler die feiten vertellen. Een manier is om de operator null forgiving te gebruiken. ! U kunt de instructie wijzigen zodat deze WriteLine overeenkomt met de volgende code:

Console.WriteLine(message!.Length);

Met de operator null-vergeefs wordt de expressie niet null, zelfs als deze mogelijk null was zonder de toepassing ervan!. In dit voorbeeld is een betere oplossing om een kenmerk toe te voegen aan de handtekening van IsNotNull:

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

De System.Diagnostics.CodeAnalysis.NotNullWhenAttribute informeert de compiler dat het argument voor de obj parameter niet null is wanneer de methode true retourneert. Wanneer de methode wordt geretourneerd false, heeft het argument dezelfde null-status die het had voordat de methode werd aangeroepen.

Tip

Er is een uitgebreide set kenmerken die u kunt gebruiken om te beschrijven hoe uw methoden en eigenschappen van invloed zijn op null-status. U vindt deze informatie in het naslagartikel over de taal over nullable statische analysekenmerken.

Het oplossen van een waarschuwing voor het dereferenceren van een mogelijk-nul-variabele omvat een van de volgende drie technieken:

  • Voeg een ontbrekende null-controle toe.
  • Voeg null-analyse-attributen toe aan API's om de statische analyse van de nulltoestand door de compiler te beïnvloeden. Deze kenmerken informeren de compiler wanneer een retourwaarde of argument mogelijk null of niet null moet zijn na het aanroepen van de methode.
  • Pas de null forgiving-operator ! toe op de expressie, die de toestand dwingt niet-null te zijn en.

Mogelijke null toegekend aan een niet-nullbare verwijzing

Deze set waarschuwingen waarschuwt u dat u een variabele waarvan het type niet-nullbaar is, toewijst aan een expressie waarvan de null-statusmogelijk null kan zijn. Deze waarschuwingen zijn:

  • Cs8597 - Gegenereerde waarde kan null zijn.
  • CS8600 - De null-letterlijke waarde of een mogelijke null-waarde converteren naar een niet-nullable type.
  • CS8601 - Mogelijke null-verwijzingstoewijzing.
  • CS8603 - Mogelijk nul-verwijzingsresultaat.
  • CS8604 - Mogelijk null-verwijzingsargument voor parameter.
  • CS8605 - Een mogelijk null-waarde de-unboxen.
  • CS8625 - Kan null-letterlijke waarde niet converteren naar niet-null-verwijzingstype.
  • CS8629 - Nullable-waardetype kan een nulwaarde zijn.

De compiler verzendt deze waarschuwingen wanneer u probeert een expressie toe te wijzen die mogelijk null is aan een variabele die niet kan worden ingetrokken. Voorbeeld:

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

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

De verschillende waarschuwingen geven details over de code, zoals toewijzing, ontboxen van toewijzing, retourinstructies, argumenten voor methoden en gooi-expressies.

U kunt een van de drie acties uitvoeren om deze waarschuwingen aan te pakken. Een manier om dit te doen, is het toevoegen van de ?-aantekening om van de variabele een 'nullable' referentietype te maken. Deze wijziging kan andere waarschuwingen veroorzaken. Als je een variabele wijzigt van een niet-null-verwijzing naar een nullable-verwijzing, verandert de standaard null-status van niet-null naar misschien-null. Tijdens de statische analyse van de compiler worden gevallen gevonden waarin u een variabele dereferenceert die mogelijk nullis.

Met de andere acties wordt de compiler geïnstrueerd dat de rechterzijde van de toewijzing niet null is. De uitdrukking aan de rechterzijde kan op null gecontroleerd worden voordat deze wordt toegewezen, zoals in het volgende voorbeeld te zien is.

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

In de vorige voorbeelden ziet u hoe de retourwaarde van een methode wordt toegewezen. U maakt aantekeningen op de methode (of eigenschap) om aan te geven wanneer een methode een niet-null-waarde retourneert. De System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute vaak geeft aan dat een retourwaarde niet null is wanneer een invoerargument niet null is. Een ander alternatief is om de null forgiving-operator toe te voegen aan de rechterkant: !.

string msg = TryGetMessage(42)!;

Het oplossen van een waarschuwing voor het toewijzen van een misschien-null-expressie aan een niet-null-variabele omvat een van de vier technieken:

  • Wijzig de linkerkant van de toewijzing naar een nullbaar type. Door deze actie kunnen nieuwe waarschuwingen ontstaan wanneer u die variabele derefereert.
  • Voer een controle op null uit vóór de toewijzing.
  • Annoteer de API die de rechterkant van de toewijzing produceert.
  • Voeg de operator null forgiving toe aan de rechterkant van de toewijzing.

Niet-nullable verwijzing niet geïnitialiseerd

Deze set waarschuwingen waarschuwt u dat u een variabele toewijst waarvan het type niet nullbaar is voor een expressie waarvan de null-status misschien null is. Deze waarschuwingen zijn:

  • CS8618 - Niet-nullable variabele moet een niet-nulwaarde bevatten bij het afsluiten van de constructor. Overweeg deze als nullable te verklaren.
  • De parameter CS8762 - moet een niet-null-waarde hebben bij het afsluiten.

Bekijk de volgende klasse als voorbeeld:

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

Zowel FirstName als LastName zijn niet gegarandeerd geïnitialiseerd. Als deze code nieuw is, kunt u overwegen de openbare interface te wijzigen. Het voorgaande voorbeeld kan als volgt worden bijgewerkt:

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

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

Als u een Person object wilt maken voordat u de naam instelt, kunt u de eigenschappen initialiseren met een standaardwaarde die niet null is:

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

Een alternatief is om deze leden te wijzigen in nullable referentietypen. De Person class kan als volgt worden gedefinieerd als null moet worden toegestaan voor de naam:

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

Voor bestaande code zijn soms andere wijzigingen vereist om de compiler te informeren over de null-semantiek voor die leden. Het kan meerdere constructors hebben en uw klasse heeft een persoonlijke helpermethode waarmee een of meer leden worden geïnitialiseerd. U kunt de initialisatiecode verplaatsen naar één constructor en ervoor zorgen dat alle constructors de code aanroepen met de algemene initialisatiecode. U kunt ook de System.Diagnostics.CodeAnalysis.MemberNotNullAttribute kenmerken en System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute kenmerken gebruiken. Deze kenmerken informeren de compiler dat een lid niet-null- nadat de methode is geretourneerd. In de volgende code ziet u een voorbeeld van elk. De Person klasse maakt gebruik van een algemene constructor die wordt aangeroepen door alle andere constructors. De Student klasse heeft een helpermethode die is voorzien van een aantekening met het System.Diagnostics.CodeAnalysis.MemberNotNullAttribute kenmerk:


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

Ten slotte kunt u de operator null forgiving gebruiken om aan te geven dat een lid in een andere code is geïnitialiseerd. Bekijk voor een ander voorbeeld de volgende klassen die een Entity Framework Core-model vertegenwoordigen:

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

De DbSet eigenschap wordt geïnitialiseerd naar null!. Hiermee wordt aan de compiler aangegeven dat de eigenschap is ingesteld op een niet-null-waarde . In feite voert de basis DbContext de initialisatie van de set uit. De statische analyse van de compiler haalt dat niet op. Zie het artikel over het werken met Nullable Reference Types in EF Core voor meer informatie over het werken met null-referentietypen en Entity Framework Core.

Het corrigeren van een waarschuwing voor het niet initialiseren van een niet-nullbaar lid betreft een van de vier technieken:

  • Wijzig de constructors of veld initializers om ervoor te zorgen dat alle niet-nullable velden worden geïnitialiseerd.
  • Wijzig een of meer leden in null-typen.
  • Aantekeningen toevoegen aan helpermethoden om aan te geven welke leden zijn toegewezen.
  • Een initializer toevoegen aan null! om aan te geven dat het lid in andere code is geïnitialiseerd.

Niet overeenkomen in declaratie voor null-baarheid

Veel waarschuwingen geven aan dat null-waarden niet overeenkomen tussen handtekeningen voor methoden, gemachtigden of typeparameters.

  • CS8608 - Nullbaarheid van verwijzingstypen in type komt niet overeen met het overschreven lid.
  • CS8609 - Nullbaarheid van referentietypen in de retourwaarde komt niet overeen met het overschreven lid.
  • CS8610 - Nullability van referentietypen in typeparameter stemt niet overeen met het overschreven lid.
  • CS8611 - Nullability van referentietypen in typeparameter komt niet overeen met gedeeltelijke methodeverklaring.
  • CS8612 - Nullbaarheid van referentietypen in het type komt niet overeen met impliciet geïmplementeerde lid.
  • CS8613 - Nullabiliteit van referentietypen in de retourneerwaarde komt niet overeen met het impliciet geïmplementeerde lid.
  • CS8614 - Nullability van referentietypen in het type van het parameter komt niet overeen met een impliciet geïmplementeerd lid.
  • CS8615 - Nullabiliteit van referentietypen in type komt niet overeen met geïmplementeerd lid.
  • CS8616 - De nullabiliteit van referentietypen in de retourwaarde komt niet overeen met het geïmplementeerde lid.
  • CS8617 - De null-beperkingen van referentietypen in het type van parameter komt niet overeen met het geïmplementeerde lid.
  • CS8619 - Nullabiliteit van referentietypen in de waarde komt niet overeen met het doeltype.
  • CS8620 - Argument kan niet worden gebruikt voor de parameter vanwege verschillen in de nullbaarheid van referentietypen.
  • CS8621 - Nullability van referentietypen in het retourtype komt niet overeen met de doeldelegee (mogelijk vanwege nullbaarheid-attributen).
  • CS8622 - Nullability van referentietypen in parametertype komt niet overeen met de doeldelegate (mogelijk vanwege nullability-attributen).
  • CS8624 - Argument kan niet worden gebruikt als uitvoer vanwege verschillen in de null-baarheid van verwijzingstypen.
  • CS8631 - Het type kan niet worden gebruikt als typeparameter in het generieke type of de methode. Nullbaarheid van het typeargument komt niet overeen met de beperking.
  • CS8633 - Nullability in beperkingen voor de typeparameter van de methode komt niet overeen met de beperkingen voor de typeparameter van de interfacemethode. Overweeg in plaats daarvan om een expliciete interface-implementatie te gebruiken.
  • CS8634 - Het type kan niet worden gebruikt als typeparameter in het algemene type of de methode. Null-waarde van het typeargument komt niet overeen met de beperking 'klasse'.
  • CS8643 - Nullability van verwijzingstypen in expliciete interfaceaanduiding komt niet overeen met de interface die door het type is geïmplementeerd.
  • CS8644 - Type implementeert geen interfacelid. De nullbaarheid van referentietypen in de interface die door het basistype is geïmplementeerd, komt niet overeen.
  • CS8645 - Het lid staat al vermeld in de interfacelijst van het type met een andere nullwaarde van referentietypen.
  • CS8667 - Gedeeltelijke methodedeclaraties hebben inconsistente nullbaarheid in beperkingen voor de typeparameter.
  • CS8714 - Het type kan niet worden gebruikt als typeparameter in het algemene type of de methode. De null-waarde van het typeargument komt niet overeen met de beperking 'notnull'.
  • CS8764 - Nulleerbaarheid van het retourtype komt niet overeen met het overschreven lid (mogelijk vanwege nulleerbaarheidsattributen).
  • CS8765 - Nullabiliteit van het type van de parameter komt niet overeen met het overschreven lid (mogelijk vanwege nullabiliteitkenmerken).
  • CS8766 - De nullability van referentietypen in het retourtype komt niet overeen met het impliciet geïmplementeerde lid (mogelijk door nullability-attributen).
  • CS8767 - Nullability van referentietypen in het type van de parameter van komt niet overeen met impliciet geïmplementeerd lid (mogelijk vanwege nullabiliteit attributen).
  • CS8768 - De nullbaarheid van referentietypen in het retourtype komt niet overeen met het geïmplementeerde lid (mogelijk vanwege nullbaarheid attributen).
  • CS8769 - De nullability van referentietypen in het type van parameter stemt niet overeen met het geïmplementeerde lid (mogelijk vanwege nullabiliteitsattributen).
  • CS8819 - Nullbaarheid van referentietypen in de retourwaarde komt niet overeen met de gedeeltelijke methodedeclaratie.

De volgende code demonstreert CS8764:

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

In het voorgaande voorbeeld ziet u een virtual methode in een basisklasse en een override met een andere null-waarde. De basisklasse retourneert een niet-nullable tekenreeks, maar de afgeleide klasse retourneert een tekenreeks die null kan bevatten. Als de string en string? worden omgekeerd, zou dit zijn toegestaan omdat de afgeleide klasse restrictiever is. Op dezelfde manier moeten parameterdeclaraties overeenkomen. Parameters in de overschrijvingsmethode kunnen null toestaan, zelfs wanneer de basisklasse dat niet doet.

Andere situaties kunnen deze waarschuwingen genereren. U hebt een niet-overeenkomende declaratie van een interfacemethode en de implementatie van die methode. Of een delegatietype en de uitdrukking voor die delegate verschillen. Een typeparameter en het typeargument verschillen in nulbaarheidsstatus.

Werk de juiste declaratie bij om deze waarschuwingen op te lossen.

Code komt niet overeen met kenmerkdeclaratie

In de voorgaande secties wordt besproken hoe u kenmerken voor null-bare statische analyse kunt gebruiken om de compiler te informeren over de null-semantiek van uw code. De compiler waarschuwt u als de code niet voldoet aan de beloften van dat kenmerk:

  • CS8607 - Een mogelijke null-waarde kan niet worden gebruikt voor een type dat is gemarkeerd met [NotNull] of [DisallowNull]
  • CS8763 - Een methode die is gemarkeerd[DoesNotReturn], mag niet worden geretourneerd.
  • Cs8770-methode - ontbreekt [DoesNotReturn] aan aantekeningen om het geïmplementeerde of overschreven lid te vinden.
  • CS8774 - lid moet een niet-null-waarde hebben bij het verlaten.
  • Cs8775-lid - moet een niet-null-waarde hebben bij het afsluiten.
  • CS8776 - Member kan niet worden gebruikt in dit kenmerk.
  • CS8777 - De parameter moet een niet-null-waarde hebben bij het afsluiten.
  • De parameter CS8824 - moet een niet-null-waarde hebben bij het afsluiten omdat de parameter niet null is.
  • De retourwaarde cs8825 - moet niet-null zijn omdat de parameter niet null is.

Houd rekening met de volgende methode:

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

}

De compiler geeft een waarschuwing omdat de message-parameter wordt toegewezen nullen de methode true retourneert. Het NotNullWhen kenmerk geeft aan dat dit niet moet gebeuren.

Als u deze waarschuwingen wilt oplossen, werkt u uw code bij zodat deze overeenkomt met de verwachtingen van de toegepaste kenmerken. U kunt de kenmerken of het algoritme wijzigen.

Uitputtende switchexpressie

Schakelexpressies moeten volledig zijn, wat betekent dat alle invoerwaarden moeten worden verwerkt. Zelfs voor niet-null-referentietypen moet de null waarde worden opgegeven. De compiler geeft waarschuwingen wanneer de null-waarde niet wordt verwerkt:

  • CS8655 - De switchexpressie verwerkt geen null-invoer (dit is niet volledig).
  • CS8847 - De switchexpressie verwerkt geen enkele null-invoer (dit is niet volledig). Een patroon met een 'when'-component kan echter overeenkomen met deze waarde.

In de volgende voorbeeldcode ziet u deze voorwaarde:

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

De invoerexpressie is een string, geen string?. Deze waarschuwing wordt nog steeds gegenereerd door de compiler. Het { } patroon verwerkt alle niet-null-waarden, maar komt niet overeen null. Als u deze fouten wilt oplossen, kunt u een expliciet null geval toevoegen of het { } vervangen door het _ patroon (verwijderen). Het wegwerppatroon komt overeen met een null-waarde naast elke andere waarde.