Fouten en waarschuwingen met betrekking tot leden oplossen die een interface implementeren

In dit artikel worden de volgende compilerfouten behandeld:

• CS0071: Een expliciete interface-implementatie van een gebeurtenis moet de syntaxis van de gebeurtenistoegangsfunctie gebruiken.
• CS0106: De wijzigingsfunctie is niet geldig voor dit item.
• CS0277: Het lid implementeert het interfacelid niet omdat het niet openbaar is.
• CS0425: De beperkingen voor de typeparameter van de methode moeten overeenkomen met de beperkingen voor de typeparameter van de interfacemethode. Overweeg in plaats daarvan een expliciete interface-implementatie te gebruiken.
• CS0460: Beperkingen voor onderdrukkings- en expliciete interface-implementatiemethoden worden overgenomen van de basismethode, zodat ze niet rechtstreeks kunnen worden opgegeven, met uitzondering van een 'klasse' of een 'struct'-beperking.
• CS0470: De methode kan geen interfacetoegangsfunctie voor het type implementeren. Gebruik een expliciete interface-implementatie.
• CS0473: Expliciete interface-implementatie 'methodenaam' komt overeen met meer dan één interfacelid. Welk interfacelid daadwerkelijk wordt gekozen, is afhankelijk van de implementatie. Overweeg in plaats daarvan een niet-expliciete implementatie te gebruiken.
• CS0531: Interfaceleden kunnen geen definitie hebben.
• CS0535: Lid implementeert geen interfacelid.
• CS0538: Lid in expliciete interfacedeclaratie is geen interface.
• CS0539: Lid in expliciete interfacedeclaratie wordt niet gevonden onder leden van de interface die kunnen worden geïmplementeerd.
• CS0540: Het type implementeert geen interfacelid.
• CS0541: Expliciete interfacedeclaratie kan alleen worden gedeclareerd in een klasse, record, struct of interface.
• CS0550: Lid voegt een accessor toe die niet in het interfacelid voorkomt.
• CS0551: Er ontbreekt een accessor voor expliciete interface-implementatie.
• CS0630: Lid kan interfacelid niet implementeren omdat het een __arglist parameter heeft.
• CS0686: Accessor kan geen interfacelid implementeren. Gebruik een expliciete interface-implementatie.
• CS0736: Lid implementeert geen exemplaarinterfacelid. Het interfacelid kan niet worden geïmplementeerd omdat het statisch is.
• CS0737: Lid implementeert geen interfacelid. Er kan geen interfacelid worden geïmplementeerd omdat het niet openbaar is.
• CS0738: Lid implementeert geen interfacelid. Dit kan niet omdat deze niet het overeenkomende retourtype heeft.
• CS8705: Interfacelid heeft geen meest specifieke implementatie. Geen van beide leden is het meest specifiek.
• CS8854: Lid implementeert geen interfacelid.
• CS9333: Parametertype moet overeenkomen met geïmplementeerd lid.
• CS9334: Retourtype moet overeenkomen met geïmplementeerd lid.

Interfacedeclaratie en syntaxis

De volgende fouten hebben betrekking op de juiste syntaxis en structuur bij het declareren van expliciete interface-implementaties:

• CS0071: Een expliciete interface-implementatie van een gebeurtenis moet de syntaxis van de gebeurtenistoegangsfunctie gebruiken.
• CS0106: De wijzigingsfunctie is niet geldig voor dit item.
• CS0531: Interfaceleden kunnen geen definitie hebben.
• CS0538: Een lid in de expliciete interface-declaratie is geen interface.
• CS0541: Expliciete interfacedeclaratie kan alleen worden gedeclareerd in een klasse, record, struct of interface.

U kunt deze fouten corrigeren met behulp van de volgende technieken:

• U moet handmatig add en remove event-accessors opgeven wanneer u expliciet een interface-gebeurtenis (CS0071) implementeert. De compiler genereert deze accessors niet automatisch voor expliciete interface-implementaties, dus u moet deze expliciet definiëren om op te geven hoe de gebeurtenis wordt opgeslagen en beheerd.
• Verwijder de public wijzigingsfunctie uit expliciete interface-implementaties (CS0106). Expliciete interface-implementaties zijn impliciet openbaar wanneer ze worden geopend via het interfacetype, waardoor het public trefwoord redundant en niet is toegestaan in deze context.
• Verwijder de abstract wijzigingsfunctie uit expliciete interface-implementaties (CS0106). Expliciete interface-implementaties bieden de werkelijke implementatie en kunnen niet als abstract worden gemarkeerd omdat ze niet kunnen worden overschreven in afgeleide klassen.
• Verwijder de hoofdtekst van de methode uit declaraties van interfaceleden of verplaats de implementatie naar een klasse of struct waarmee de interface (CS0531) wordt geïmplementeerd. Voor C# 8.0 kunnen interfaceleden geen implementaties bevatten; vanaf C# 8.0 kunt u standaardinterfacemethoden opgeven met behulp van specifieke syntaxis.
• Controleer of het type dat is opgegeven in de expliciete interfacedeclaratie een echt interfacetype (CS0538) is. Alleen interfacetypen kunnen worden gebruikt in expliciete interface-implementatiesyntaxis; als u probeert een klasse of een ander type niet-interface te gebruiken, schendt u de expliciete implementatieregels.
• Verplaats expliciete interfacedeclaraties naar een klasse of struct die de interface in de basislijst (CS0541) declareert. Expliciete interface-implementaties moeten worden weergegeven in de hoofdtekst van een klasse of struct-type en kunnen niet worden gedeclareerd op het niveau van de naamruimte of in andere contexten.

Zie Interfaces, Expliciete interface-implementatie en Interface-gebeurtenissen implementeren voor meer informatie.

Retourtypen en handtekeningen

De volgende fouten treden op wanneer de handtekening van de implementatiemethode niet overeenkomt met de declaratie van het interfacelid:

• CS0738: Lid implementeert geen interfacelid. Dit kan niet omdat deze niet het overeenkomende retourtype heeft.
• CS8854: Lid implementeert geen interfacelid.
• CS9333: Parametertype moet overeenkomen met geïmplementeerd lid.
• CS9334: Retourtype moet overeenkomen met geïmplementeerd lid.

U kunt deze fouten corrigeren met behulp van de volgende technieken:

• Wijzig het retourtype van de implementatiemethode zodat deze exact overeenkomt met het retourtype dat is gedeclareerd in het interfacelid (CS0738, CS9334). De handtekening van de implementatie moet exact overeenkomen met de interfacedeclaratie omdat de methodehandtekening deel uitmaakt van het contract dat bepaalt welk interfacelid wordt geïmplementeerd.
• Zorg ervoor dat parametertypen in de implementatiemethode exact overeenkomen met de parametertypen die zijn gedeclareerd in het interfacelid (CS9333). Elke parameter moet hetzelfde type hebben op dezelfde positie als opgegeven in de interfacedeclaratie, omdat parametertypen fundamentele onderdelen zijn van de methodehandtekening die de compiler gebruikt om implementaties aan interfaceleden te koppelen.
• Voeg een init accessor toe aan de implementatieeigenschap wanneer de interface-eigenschap een init setter (CS8854) declareert. Met het trefwoord init kan een eigenschap tijdens het construeren van objecten worden geïnitialiseerd, waarna aanpassing niet langer mogelijk is. De implementerende eigenschap moet ditzelfde alleen-initialisatiegedrag bieden om aan het interfacecontract te voldoen.

Zie Interfaces, Eigenschappen en Alleen-init-setters voor meer informatie.

Ontbrekende of onvolledige implementaties

De volgende fouten treden op wanneer een klasse een interface niet volledig kan implementeren of leden implementeert die niet overeenkomen met het interfacecontract:

• CS0535: Lid implementeert geen interfacelid.
• CS0550: Lid voegt een accessor toe die niet is gevonden in het interfacelid.
• CS0551: Er ontbreekt een accessor voor expliciete interface-implementatie.

U kunt deze fouten corrigeren met behulp van de volgende technieken:

• Geef een implementatie op voor elk lid dat in de interface is gedeclareerd of declareer het type als abstract (CS0535). Elk lid moet worden geïmplementeerd om te voldoen aan de interfacevereisten.
• Verwijder alle accessors uit de implementatie-eigenschap die niet zijn gedeclareerd in de interface-eigenschap (CS0550). De implementatieeigenschap kan alleen de toegangsrechten bevatten die expliciet zijn gedeclareerd in de interfacedefinitie, zodat de implementatie geen functionaliteit toevoegt buiten wat het interfacecontract aangeeft.
• Voeg alle vereiste toegangsrechten toe aan de expliciete interface-implementatie zodat deze overeenkomt met de interfacedeclaratie (CS0551). Elke toegangsfunctie die in de interface is gedeclareerd, moet een bijbehorende toegangsfunctie hebben in de implementatie met overeenkomende handtekeningen, omdat de implementatie moet voldoen aan het volledige accessorcontract dat is gedefinieerd door de interface.

Zie Interfaces en eigenschappen voor meer informatie.

Leden vergelijken en oplossen

De volgende fouten treden op bij het implementeren van interfaceleden die niet aanwezig zijn in de interface of wanneer het betreffende type de interface niet declareert:

• CS0539: Lid in expliciete interfacedeclaratie wordt niet gevonden onder leden van de interface die kunnen worden geïmplementeerd.
• CS0540: Het bevattende type implementeert het interfacelid niet.

U kunt deze fouten corrigeren met behulp van de volgende technieken:

• Controleer of de lidnaam en handtekening in de expliciete interface-implementatie exact overeenkomen met een lid dat in de interface is gedeclareerd of verwijder de onjuiste implementatie (CS0539). Het lid dat u probeert te implementeren, moet daadwerkelijk bestaan in de interfacedefinitie met overeenkomende naam, retourtype en parametertypen, omdat expliciete interface-implementatie nauwkeurige correspondentie met het interfacecontract vereist.
• Voeg de interface toe aan de basislijst van de klasse of struct of verwijder de expliciete interface-implementatie (CS0540). Een type kan alleen expliciet leden van interfaces implementeren die het declareert in de overnamelijst, dus het implementatietype moet de interfacerelatie tot stand brengen voordat het expliciete implementaties kan bieden.

Zie Interfaces en Expliciete interface-implementatie voor meer informatie.

Algemene typebeperkingen

De volgende fouten treden op bij het implementeren van algemene interfacemethoden met typeparameterbeperkingen:

• CS0425: De beperkingen voor de typeparameter van de methode moeten overeenkomen met de beperkingen voor de typeparameter van de interfacemethode. Overweeg in plaats daarvan een expliciete interface-implementatie te gebruiken.
• CS0460: Beperkingen voor onderdrukkings- en expliciete interface-implementatiemethoden worden overgenomen van de basismethode, zodat ze niet rechtstreeks kunnen worden opgegeven, met uitzondering van een 'klasse' of een 'struct'-beperking.

U kunt deze fouten corrigeren met behulp van de volgende technieken:

• Zorg ervoor dat de where component in de implementatiemethode identiek is aan de declaratie van de interfacemethode of overeenkomt met de semantische betekenis van de beperkingen (CS0425). De parameterbeperkingen van het type in de implementatie moeten overeenkomen met de parameters die zijn gedefinieerd in de interface of basismethode.
• Verwijder expliciete beperkingsdeclaraties uit override-methoden en expliciete interface-implementatiemethoden (CS0460). De override methode neemt automatisch de restricties over van de basis- of interfacemethode, het opnieuw declareren is daarom overbodig en niet toegestaan, behalve in specifieke gevallen toegestaan in C# 8 en hoger.
• Pas de default beperking toe om dubbelzinnigheden met null-referentietypen op te lossen in onderdrukkings- en expliciete interfaceimplementaties bij gebruik van C# 9 of hoger (CS0460). Met deze uitzondering op de overnameregel voor beperkingen kunt u expliciet de standaardbeperking opgeven om null-bare annotatiecontexten te onderscheiden.
• Expliciet specificeren van where T : class of where T : struct beperkingen op overschrijvings- en expliciete interface-implementatiemethoden wanneer u C# 8 of hoger gebruikt om nullable verwijzingstypeaantekeningen (CS0460) in te schakelen. Deze specifieke beperkingen zijn toegelaten om ondersteuning te bieden voor analyse van nullbare referentietypen voor typeparameters die zijn beperkt tot verwijzings- of waardetypen.

Zie Beperkingen voor typeparameters, interfaces en null-referentietypen voor meer informatie.

Zichtbaarheid van methoden en modifiers

De volgende fouten treden op bij het implementeren van interfacemethoden met onjuiste toegankelijkheid of modificators:

• CS0736: Lid implementeert geen exemplaarinterfacelid. Het interfacelid kan niet worden geïmplementeerd omdat het statisch is.
• CS0737: Lid implementeert geen interfacelid. Er kan geen interfacelid worden geïmplementeerd omdat het niet openbaar is.

U kunt deze fouten corrigeren met behulp van de volgende technieken:

• Verwijder de static wijzigingsfunctie uit de methodedeclaratie waarmee het interfacelid (CS0736) wordt geïmplementeerd. Voor C# 10 zijn interfaceleden exemplaarleden, niet statische leden.
• Voeg de public toegangsaanpassing toe aan de methode waarmee het interfacelid (CS0737) wordt geïmplementeerd. Alle interfaceleden zijn impliciet public omdat interfaces een contract definiëren voor openbaar gedrag, zodat de implementatiemethode ook openbare toegankelijkheid moet hebben om toegankelijk te zijn via de interfacereferentie.

Zie Interfaces en toegangsmodifiers voor meer informatie.

Accessor-implementatie en conflicten

De volgende fouten treden op bij het implementeren van interface-eigenschappen of gebeurtenissen met toegangsmethoden die zichtbaarheidsproblemen of naamconflicten hebben:

• CS0277: Lid implementeert geen interfacelid omdat het niet openbaar is.
• CS0470: De methode kan geen interfacetoegangsfunctie voor het type implementeren. Gebruik een expliciete interface-implementatie.
• CS0686: Accessor kan geen interfacelid implementeren. Gebruik een expliciete interface-implementatie.

U kunt deze fouten corrigeren met behulp van de volgende technieken:

• Verwijder eventuele toegangsaanpassingen uit eigenschapstoegangsors die de zichtbaarheid beperken tot minder zichtbaar dan public, of voeg de public wijziging toe als deze ontbreekt (CS0277). Alle interfaceleden zijn impliciet public, dus de implementatietoegangsfunctie moet ook openbare toegankelijkheid hebben om te voldoen aan het interfacecontract en toegankelijk zijn via het interfacetype.
• Vervang methoden door namen die op accessors lijken (zoals get_PropertyName) met de juiste eigenschappensyntaxis, door gebruik te maken van expliciete interface-implementatie (CS0470). De compiler genereert intern toegangsmethoden voor eigenschappen en probeert methoden handmatig te maken met deze gereserveerde namen, in strijd met het mechanisme voor de implementatie van eigenschappen.
• Gebruik de syntaxis van expliciete interface-implementatie om naamconflicten op te lossen wanneer de interface methodenamen bevat die overeenkomen met de automatisch gegenereerde accessormethoden (CS0686). De compiler genereert automatisch methoden zoals get_Property en set_Property voor eigenschappen, en add_Eventremove_Event voor gebeurtenissen, dus als een interface methoden declareert met deze exacte namen, is expliciete implementatie vereist om onderscheid te maken tussen de interfacemethode en de door de compiler gegenereerde toegangsfunctie.

Zie Interfaces, eigenschappen en gebeurtenissen voor meer informatie.

Dubbelzinnige en conflicterende implementaties

De volgende fouten treden op wanneer de compiler niet kan bepalen welke interface-implementatie moet worden gebruikt:

• CS0473: Expliciete interface-implementatie 'methodenaam' komt overeen met meer dan één interfacelid. Welk interfacelid daadwerkelijk wordt gekozen, is afhankelijk van de implementatie. Overweeg in plaats daarvan een niet-expliciete implementatie te gebruiken.
• CS8705: Interfacelid 'member' heeft geen specifieke implementatie. Geen van beide is het meest specifiek.

U kunt deze fouten corrigeren met behulp van de volgende technieken:

• Elimineer de expliciete implementatie van de interface en gebruik in plaats daarvan één impliciete openbare implementatie voor beide interfacemethoden (CS0473). Wanneer een algemene methode dezelfde handtekening krijgt als een niet-algemene methode (zoals bij de implementatie ITest<int> waarbij beide TestMethod(int) en TestMethod(T) identiek worden), kan het metagegevenssysteem van de algemene taalinfrastructuur niet eenduidig bepalen welk interfacelid aan welke implementatiesite verbindt, dus door impliciete implementatie te gebruiken, kan de ene methode voldoen aan beide interfacevereisten.
• Geef een expliciete implementatie op in de implementatieklasse of struct waarmee de dubbelzinnigheid tussen meerdere standaard implementaties (CS8705) wordt opgelost. Deze fout treedt meestal op bij ruitovernamepatronen waarbij een klasse meerdere interfaces implementeert die elk standaard implementaties voor hetzelfde lid bieden. De compiler moet u expliciet opgeven welke implementatie moet worden gebruikt of uw eigen implementatie bieden.
• Herstructureer de interfacehiërarchie om conflicten met diamantovername te voorkomen waarbij meerdere interfaces standaard implementaties bieden voor hetzelfde lid (CS8705). Door de interfacerelaties opnieuw te ontwerpen of de standaard implementaties in één interface te consolideren, kunt u de dubbelzinnigheid elimineren waardoor de compiler de meest specifieke implementatie niet kan bepalen.

Zie Interfaces en standaardinterfacemethoden voor meer informatie.

Speciale implementatiebeperkingen

De volgende fout treedt op wanneer u speciale parametertypen gebruikt die niet compatibel zijn met interface-implementatie:

• CS0630: Een lid kan een lid van een interface niet implementeren omdat het een __arglist-parameter heeft.

U kunt deze fout corrigeren met behulp van de volgende technieken:

• Verwijder de __arglist parameter uit de implementatiemethode (CS0630). Met __arglist het trefwoord kunnen methoden variabele getallen van argumenten op een onbeheerde manier accepteren, maar deze functie is niet compatibel met interface-implementatie, omdat interfacecontracten voorspelbare, typeveilige handtekeningen vereisen die tijdens het compileren kunnen worden geverifieerd.
• Vervang de __arglist parameter door een params matrixparameter voor lijsten met argumenten met variabele lengte (CS0630). In tegenstelling tot __arglist, biedt het params trefwoord een mechanisme dat typeveiligheid biedt voor het accepteren van een variabel aantal argumenten, dat volledig compatibel is met de implementatie van interfaces en de typeveiligheid bij compileertijd onderhoudt die interfaces bij het compileren vereisen.

Zie Interfaces en het trefwoord 'params' voor meer informatie.