Fouten en waarschuwingen in door de gebruiker gedefinieerde operatordeclaraties oplossen

In dit artikel worden de volgende compilerfouten behandeld:

CS0056: Inconsistente toegankelijkheid: het retourtype 'type' is minder toegankelijk dan de operator 'operator'
CS0057: Inconsistente toegankelijkheid: parametertype 'type' is minder toegankelijk dan operator 'operator'
CS0215: Het retourtype Waar of Onwaar moet bool zijn
CS0216: Voor de operator 'operator' moet ook een overeenkomende operator 'missing_operator' worden gedefinieerd
CS0217: Als u van toepassing wilt zijn als een kortsluitingsoperator, moet een door de gebruiker gedefinieerde logische operator (operator) hetzelfde retourtype hebben als het type van de 2 parameters.
CS0218: Het type ('type') moet declaraties van operator true en operator false bevatten
CS0448: Het retourtype voor de ++ of ---operator moet het omvattende type zijn of hiervan afgeleid zijn
CS0552: 'conversieroutine': door de gebruiker gedefinieerde conversie naar/van interface
CS0553: 'conversieroutine': door de gebruiker gedefinieerde conversie naar/van basisklasse
CS0554: 'conversieroutine': door de gebruiker gedefinieerde conversie naar/van afgeleide klasse
CS0555: Een door de gebruiker gedefinieerde operator kan geen object van het omsluittype accepteren en converteren naar een object van hetzelfde omsluittype
CS0556: Een door de gebruiker gedefinieerde conversie moet een conversie naar of van het omsluitende type zijn
CS0557: Dubbele door de gebruiker gedefinieerde conversie in type
CS0558: Door de gebruiker gedefinieerde operator moet worden gedeclareerd als statisch en openbaar
CS0559: Het parametertype voor de ++-operator of de ---operator moet het omvattende type zijn
CS0562: De parameter van een unaire operator moet het type bevatten
CS0563: Een van de parameters van een binaire operator moet van het omvattende type zijn
CS0564: De eerste operand van een overbelaste ploegendienstoperator moet hetzelfde type hebben als het type dat het bevat en het type van de tweede operand moet int zijn
CS0567: Interfaces mogen geen operators bevatten
CS0590: Door de gebruiker gedefinieerde operators kunnen geen ongeldige waarde retourneren
CS0660: Type definieert operator == of operator != maar overschrijft Object.Equals(object o)niet
CS0661: Type definieert operator == of operator != maar overschrijft Object.GetHashCode()niet
CS0715: Statische klassen kunnen geen door de gebruiker gedefinieerde operators bevatten
CS1037: Overbelastingsoperator verwacht
CS1553: Declaratie is ongeldig; gebruik 'modifier operator <dest-type> (...' in plaats van
CS8930: Expliciete implementatie van een door de gebruiker gedefinieerde operator moet statisch zijn.
CS8931: Expliciete implementatie moet openbaar worden verklaard om interfacelid in type te implementeren.
CS9023: Operator kan niet worden gecontroleerd.
CS9024: Operator kan niet onbeheerd worden gemaakt.
CS9025: Voor operator moet ook een overeenkomende niet-gecontroleerde versie worden gedeclareerd.
CS9308: Door de gebruiker gedefinieerde operator moet openbaar worden gedeclareerd.
CS9310: Het retourtype voor deze operator moet ongeldig zijn.
CS9311: Type implementeert geen interfacelid. Het type kan geen lid implementeren omdat een van deze leden geen operator is.
CS9312: Type kan overgenomen lid niet overschrijven omdat een van deze leden geen operator is.
CS9313: Overladen samengesteld toewijzingsoperator accepteert één parameter.
CS9340: Operator kan niet worden toegepast op operanden. De dichtstbijzijnde niet-toe te passen kandidaat wordt weergegeven.
CS9341: Operator kan niet worden toegepast op operand. De dichtstbijzijnde ongeschikte kandidaat wordt getoond.
CS9342: Operatorresolutie is dubbelzinnig tussen de volgende leden.

Vereisten voor operatorhandtekening

CS0448: Het retourtype voor de ++ of -- operator moet het bevattende type zijn of ervan afgeleid zijn.
CS0559: Het parametertype voor de ++ of -- operator moet het omhullende type zijn.
CS0562: De parameter van een unaire operator moet van het type zijn dat het bevat.
CS0563: Een van de parameters van een binaire operator moet het omvattende type zijn.
CS0564: De eerste operand van een overbelaste ploegendienstoperator moet hetzelfde type hebben als het type dat het bevat en het type van de tweede operand moet int zijn.
CS0567: Interfaces kunnen geen operators bevatten.
CS0590: Door de gebruiker gedefinieerde operators kunnen geen ongeldige waarde retourneren.
CS9310: Het retourtype voor deze operator moet ongeldig zijn.
CS9340: Operator kan niet worden toegepast op operanden. De dichtstbijzijnde ongeschikte kandidaat wordt weergegeven.
CS9341: Operator kan niet worden toegepast op operand. De dichtstbijzijnde niet van toepassing zijnde kandidaat wordt weergegeven.
CS9342: Operatorresolutie is dubbelzinnig tussen de volgende elementen.

Als u operators met de juiste handtekeningen wilt declareren, volgt u deze vereisten voor het specifieke operatortype. Zie Overbelasting van operatoren voor meer informatie.

De compiler retourneert het omvattende type (of een afgeleid type) van de ++- en ---operators (CS0448).
Gebruik het bevattende type als de parameter voor ++ en -- operators (CS0559).
Gebruik het bevattende type als de parameter voor unaire operators (CS0562).
Neem het bevattende type op als ten minste één parameter in binaire operators (CS0563).
Gebruik het omvattende type als de eerste parameter en int als de tweede parameter voor shiftoperators (CS0564).
Declareer geen operators in interfaces (CS0567). Interfaces kunnen geen operator-implementaties bevatten.
Retourneert een niet-ongeldig type van de meeste operators (CS0590), met uitzondering van specifieke operators waarvoor retouren zijn vereist void (CS9310).
Voorzie operator-overladers die de juiste parametertypen accepteren om oplossingsfouten te voorkomen (CS9340, CS9341).
Onderscheid operator-aanroepen door expliciete casts te gebruiken of meer specifieke overload-varianten te bieden (CS9342).

Belangrijk

De vereisten voor ondertekening voor statische binaire operators en de bijbehorende instance samengestelde toewijzingsoperatoren verschillen. Zorg ervoor dat de handtekening overeenkomt met de gewenste declaratie.

In het volgende voorbeeld ziet u handtekeningfouten:

class C1
{
    public static int operator ++(C1 c) => 0;   // CS0448
    public static C1 operator --(C1 c) => null;   // OK
}
public class C2
{
    public static implicit operator int(C2 x) => 0;
    public static implicit operator C2(int x) => new C2();
    public static int operator ++(int aa) => 0;  // CS0559
}
public class C3
{
    public static implicit operator int(C3 x) => 0;
    public static implicit operator C3(int x) => null;
    public static C3 operator +(int aa) => 0;   // CS0562
}
public class C4
{
    public static implicit operator int(C4 x) => 0;
    public static implicit operator C4(int x) => null;
    public static int operator +(int aa, int bb) => 0;   // CS0563
}
class C5
{
    // To correct, change second operand to int, like so:
    // public static int operator << (C c1, int c2)
    public static int operator <<(C5 c1, C5 c2) => 0; // CS0564
}
interface IA
{
    int operator +(int aa, int bb);   // CS0567
}
public class C6
{
    public static void operator +(C6 A1, C6 A2) { }  // CS0590
}

Vereisten voor operatordeclaratie

CS0558: Door de gebruiker gedefinieerde operator moet statisch en openbaar worden gedeclareerd.
CS0715: Statische klassen kunnen geen door de gebruiker gedefinieerde operators bevatten.
CS1037: Overbelastingsoperator verwacht.
CS1553: Declaratie is niet geldig; gebruik 'modifier operator <dest-type> (...' in plaats van.
CS8930: Expliciete implementatie van een door de gebruiker gedefinieerde operator moet statisch zijn.
CS8931: Expliciete implementatie moet openbaar worden verklaard om interfacelid in type te implementeren.
CS9308: Door de gebruiker gedefinieerde operator moet openbaar worden gedeclareerd.

Als u operators correct wilt verklaren, volgt u deze vereisten voor modificeerders en omvattende typen. Zie Operator-overbelasting en door de gebruiker gedefinieerde conversieoperators voor meer informatie.

Declareer operators met zowel static als public modifiers (CS0558, CS9308).
Declareer geen operators in statische klassen (CS0715). Gebruik reguliere klassen of structs.
Gebruik geldige, overbelastingsbare operatorsymbolen (CS1037).
Volg de juiste syntaxis voor conversieoperators: public static implicit/explicit operator <dest-type>(<source-type> parameter) (CS1553).
Zorg ervoor dat expliciete interface-implementaties van operators static en CS8931 zijn zoals public en .

In het volgende voorbeeld ziet u declaratiefouten:

public class C
{
    static implicit operator int(C aa) => 0;   // CS0558, add public
}
public static class C1
{
    public static int operator +(C1 c) => 0;  // CS0715
}
class C2
{
    public static int implicit operator (C2 f) => 6;   // CS1553
}

Inconsistente toegankelijkheid

CS0056: Inconsistente toegankelijkheid: het retourtype 'type' is minder toegankelijk dan de operator 'operator'.
CS0057: Inconsistente toegankelijkheid: parametertype 'type' is minder toegankelijk dan operator 'operator'.

Maak alle typen die worden gebruikt in openbare operators openbaar toegankelijk om consistente toegankelijkheid in operatordeclaraties te garanderen. Zie Toegangsmodifiers voor meer informatie.

Zorg ervoor dat retourtypen ten minste dezelfde toegankelijkheid hebben als de operator (CS0056).
Zorg ervoor dat parametertypen ten minste dezelfde toegankelijkheid hebben als de operator (CS0057).

Wanneer u een public operator declareert, moeten alle typen die worden gebruikt als parameters of retourwaarden ook openbaar toegankelijk zijn.

In het volgende voorbeeld ziet u toegankelijkheidsfouten:

class C { }

public class C2
{
    public static implicit operator C(C2 a) => new C();   // CS0056
}

public class C3
{
    public static implicit operator C3(C c) => new C3();   // CS0057
}

Door de gebruiker gedefinieerde conversiebeperkingen

CS0552: Door de gebruiker gedefinieerde conversie naar/van interface.
CS0553: Door de gebruiker gedefinieerde conversie naar/van basisklasse.
CS0554: Door de gebruiker gedefinieerde conversie naar/van afgeleide klasse.
CS0555: Een door de gebruiker gedefinieerde operator kan geen object van het omsluittype accepteren en omzetten naar een object van het omsluittype.
CS0556: Een door de gebruiker gedefinieerde conversie moet afkomstig zijn van, of gericht zijn op, het insluittype.
CS0557: Dubbele gebruikersgedefinieerde conversie van type.

Volg deze beperkingen om geldige door de gebruiker gedefinieerde conversieoperators te maken. Zie Door de gebruiker gedefinieerde conversieoperators voor meer informatie.

Definieer geen conversies naar of van interfaces (CS0552). Gebruik in plaats daarvan expliciete interface-implementaties.
Definieer geen conversies naar of van basisklassen (CS0553). De conversie bestaat al via overname.
Definieer geen conversies naar of van afgeleide klassen (CS0554). De conversie bestaat al via overname.
Definieer geen conversies van het omsluitende type naar zichzelf (CS0555). Deze conversie is impliciet.
Zorg ervoor dat ten minste één type in de conversie het insluittype (CS0556) is. U kunt geen conversies tussen twee externe typen definiëren.
Definieer geen dubbele conversies (CS0557). Elke conversieoperator moet uniek zijn.

In het volgende voorbeeld ziet u fouten met conversiebeperkingen:

public interface I
{
}
public class C
{
    public static implicit operator I(C aa) => default;// CS0552
}

public class B
{
}
public class D : B
{
    public static implicit operator B(D aa) => new B();// CS0553
}

public class B2
{
    // delete the conversion routine to resolve CS0554
    public static implicit operator B2(D2 d) => new B2();// CS0554
}
public class D2 : B2 { }

public class C2
{
    public static implicit operator C2(C2 aa) => new C2();   // CS0555
}

public class C3
{
    public static implicit operator int(byte aa) => 0;   // CS0556
}

public class C4
{
    public static implicit operator int(C4 aa) => 0;

    // CS0557, delete duplicate
    public static explicit operator int(C4 aa) => 0;
}

Booleaanse operatoren en kortsluitingsoperatoren

CS0215: Het retourtype waar of onwaar van de operator moet bool zijn.
CS0216: Voor de operator moet ook een overeenkomende operator worden gedefinieerd.
CS0217: Om van toepassing te zijn als een operator voor kortsluiting, moet een door de gebruiker gedefinieerde logische operator hetzelfde retourtype hebben als het type van de 2 parameters.
CS0218: Het type moet declaraties van operator true en operator false bevatten.

Als u logische operators correct wilt definiëren, volgt u deze koppelings- en handtekeningvereisten. Zie waar- en onwaaroperators, booleaanse logische operators en door de gebruiker gedefinieerde logische operators voor meer informatie.

Retourneer bool van operator true en operator false (CS0215).
Vereiste gekoppelde operators definiëren (CS0216):
- operator == vereist operator !=
- operator < vereist operator >
- operator <= vereist operator >=
- operator true vereist operator false
Koppel het retourtype met de parametertypen voor kortsluitingsoperatoren (& en |) die met aangepaste typen (CS0217) werken.
Implementeer zowel operator true als operator false wanneer u aangepaste typen gebruikt in booleaanse contexten zoals && en || (CS0218).

In het volgende voorbeeld ziet u fouten met logische operatoren:

class C
{
    public static int operator true(C c) => 0;   // CS0215
    public static int operator false(C c) => 0; // CS0215
}

class C2
{
    public static bool operator ==(C2 left, C2 right) => left.Equals(right);   // CS0216

    public override bool Equals(object? o) => base.Equals(o);
    public override int GetHashCode() => base.GetHashCode();
}

public class C3
{
    public static bool operator true(C3 f) => false;
    public static bool operator false(C3 f) => true;
    public static implicit operator int(C3 x) => 0;
    public static int operator &(C3 f1, C3 f2) => new C3();  // CS0217
}

public class C4
{
    public static implicit operator int(C4 x) => 0;
    public static C4 operator &(C4 f1, C4 f2) => new C4();

    public static void Main()
    {
        C4 f = new C4();
        int i = f && f;   // CS0218, requires operators true and false
    }
}

Gecontroleerde operators

CS9023: Operator kan niet worden gecontroleerd
CS9024: Operator kan niet oncontroleerbaar worden gemaakt
CS9025: Een gecontroleerde operator vereist dat er ook een overeenkomende ongecontroleerde versie gedeclareerd wordt

Als u gecontroleerde operators correct wilt gebruiken, volgt u deze vereisten. Zie Rekenkundige operatoren en door de gebruiker gedefinieerde operators voor meer informatie.

Pas checked of unchecked trefwoorden alleen toe op ondersteunde rekenkundige operatoren: +, -, *, /, ++, -- en expliciete conversies (CS9023, CS9024).
Geef zowel gecontroleerde als niet-gecontroleerde versies op bij het declareren van een ingeschakelde operator (CS9025). De compiler moet beide verschillende contexten verwerken.

Interface- en erfenisvereisten

CS9311: Type implementeert geen interfacelid. Het type kan lid niet implementeren omdat een van deze leden geen operator is
CS9312: Type kan overgenomen lid niet overschrijven omdat een van deze leden geen operator is
CS9313: De overbelaste samengestelde toewijzingsoperator accepteert één parameter

Als je operators correct wilt implementeren en overschrijven, volg deze vereisten. Zie Operator-overbelasting en interfaces voor meer informatie.

Zorg ervoor dat operatordeclaraties overeenkomen met de handtekening en het type interfaceleden (CS9311). Een operator kan geen niet-operatorlid implementeren.
Controleer of overgenomen leden die worden overschreven eveneens operators zijn (CS9312). Een operator kan geen niet-operator lid overschrijven.
Declareer samengestelde toewijzingsoperators met één parameter (CS9313). De linkeroperand is impliciet this.

Gelijkheidsoperators

CS0660: Type definieert operator == of operator != maar overschrijft niet Object.Equals(object o)
CS0661: Type definieert operator == of operator != maar overschrijft Object.GetHashCode() niet

Als u gelijkheid correct wilt implementeren, overschrijft u de bijbehorende Object methoden bij het definiëren van aangepaste gelijkheidsoperators. Zie Hoe u gelijkheid van waarden definieert voor een type en gelijkheidsoperators voor meer informatie.

Overschrijf Object.Equals wanneer u operator == of operator != definieert (CS0660).
Overschrijf Object.GetHashCode wanneer u operator == of operator != definieert (CS0661).

Het negeren van deze methoden zorgt voor consistent gelijkheidsgedrag voor verschillende API's en verzamelingstypen.

Feedback

Is deze pagina nuttig?

Last updated on 2025-11-08