Fel och varningar för överlagrade eller användardefinierade operatordeklarationer

Det finns flera fel relaterade till deklarering av överlagrade operatorer. Överlagrade operatorer kallas även användardefinierade operatorer

• CS0056: Ojämn tillgänglighet: returtypen 'typ' är mindre tillgänglig än operatören 'operator'
• CS0057: Inkonsekvent tillgänglighet: parametertypen "type" är mindre tillgänglig än operatorn operator
• CS0215: Returtypen för operatorn True eller False måste vara bool
• CS0216: Operatorn "operator" kräver att en matchande operator "missing_operator" också definieras
• CS0217: För att kunna användas som kortslutningsoperator måste en användardefinierad logisk operator ('operator') ha samma returtyp som typen av dess 2 parametrar.
• CS0218: Typen ("typ") måste innehålla deklarationer av operatorn true och operator false
• CS0448: Returtypen för ++ eller -- operatorn måste vara den innehållande typen eller härledd från den innehållande typen
• CS0552: "konverteringsrutin" : användardefinierad konvertering till/från gränssnitt
• CS0553: "konverteringsrutin" : användardefinierad konvertering till/från basklass
• CS0554: "konverteringsrutin" : användardefinierad konvertering till/från härledd klass
• CS0555: Användardefinierad operator kan inte ta ett objekt av den omslutande typen och konvertera till ett objekt av den omslutande typen
• CS0556: Användardefinierad konvertering måste konverteras till eller från den omslutande typen
• CS0557: Duplicera användardefinierad konvertering i typ
• CS0558: Användardefinierad operator måste deklareras som statisk och offentlig
• CS0559: Parametertypen för ++ eller -- operatorn måste vara den innehållande typen
• CS0562: Parametern för en unary-operator måste vara den innehållande typen
• CS0563: En av parametrarna för en binär operator måste vara den innehållande typen
• CS0564: Den första operand av en överbelastad skiftoperator måste ha samma typ som den innehållande typen, och typen av den andra operanden måste vara int
• CS0567: Gränssnitt får inte innehålla operatorer
• CS0590: Användardefinierade operatorer kan inte returnera void
• CS0660: Typen definierar operator == och operator != men åsidosätter inte Object.Equals(object o)
• CS0661: Typ definierar operator == eller operator !=, men åsidosätter inte Object.GetHashCode()
• CS0715: Statiska klasser får inte innehålla användardefinierade operatorer
• CS1037: Överbelastningsbar operator förväntas
• CS1553: Deklarationen är inte giltig. Använd "modifieraroperator <av typen> (..." istället
• CS8930: Explicit implementering av en användardefinierad operator måste vara statisk.
• CS8931: Explicit implementation måste deklareras som offentlig för att implementera en gränssnittsmedlem i typen.
• CS9023: Operatorn kan inte kontrolleras.
• CS9024: Operatorn kan inte avmarkeras.
• CS9025: Operatorn kräver att en matchande icke-kontrollerad version också deklareras.
• CS9308: Användardefinierad operator måste deklareras som offentlig.
• CS9310: Returtypen för den här operatorn måste vara ogiltig.
• CS9311: Typen implementerar inte gränssnittsmedlem. Typen kan inte implementera medlem eftersom en av dem inte är en operator.
• CS9312: Typen kan inte åsidosätta ärvd medlem eftersom en av dem inte är en operator.
• CS9313: Överlagrad sammansatt tilldelningsoperator tar en parameter.

Följande avsnitt innehåller exempel på vanliga problem och hur du åtgärdar dem.

Krav för operatorsignatur

• CS0448: Returtypen för ++ eller -- operatorn måste vara den innehållande typen eller härledd från den innehållande typen.
• CS0559: Parametertypen för ++ eller -- operatorn måste vara den innehållande typen.
• CS0562: Parametern för en unary-operator måste vara den innehållande typen.
• CS0563: En av parametrarna för en binär operator måste vara den innehållande typen.
• CS0564: Den första operanden av en överlagd skiftoperator måste ha samma typ som den innehållande typen, och typen av den andra operanden måste vara int.
• CS0567: Gränssnitt får inte innehålla operatorer.
• CS0590: Användardefinierade operatorer kan inte returnera void.
• CS9310: Returtypen för den här operatorn måste vara ogiltig.

Dessa fel uppstår när operatordeklarationer inte följer de obligatoriska signaturreglerna. Varje operatortyp har specifika krav för parametertyper och returtyper.

Mer information finns i Operatoröverlagring. I följande exempel visas dessa fel:

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
}

Åtgärda dessa fel genom att se till att dina operatörsdeklarationer följer signaturkraven för den specifika operatortyp som du överbelastar.

Krav för operatordeklaration

• CS0558: Användardefinierad operator måste deklareras som statisk och offentlig.
• CS0715: Statiska klasser får inte innehålla användardefinierade operatorer.
• CS1037: Överbelastningsbar operator förväntas.
• CS1553: Deklarationen är inte giltig. Använd "modifieraroperator <av typen> (..." istället.
• CS8930: Den explicita implementeringen av en användardefinierad operator måste vara statisk.
• CS8931: Explicit implementering måste deklareras som offentlig för att implementera en gränssnittsmedlem i en typ.
• CS9308: Användardefinierad operator måste deklareras som offentlig.

Dessa fel uppstår när operatordeklarationer inte använder nödvändiga modifierare eller syntax. De flesta användardefinierade operatorer måste vara både static och public, och konverteringsoperatorer kräver specifik syntax. Mer information finns i Operatoröverlagring och Användardefinierade konverteringsoperatorer. Följande kod visar dessa fel:

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
}

Åtgärda dessa fel genom att se till att dina operatörsdeklarationer innehåller nödvändiga static och public modifierare, följer rätt syntax för konverteringsoperatorer och deklarerar inte operatorer i statiska klasser.

Inkonsekvent tillgänglighet

• CS0056: Inkonsistent åtkomst: returtypen "typ" har mindre åtkomst än operatorn "operator".
• CS0057: Inkonsekvent tillgänglighet: parametertypen 'type' är mindre tillgänglig än operatorn 'operator'.

Dessa fel uppstår när du deklarerar en offentlig operator med returtyper eller parametertyper som har mer restriktiv tillgänglighet än själva operatorn. Alla offentliga konstruktioner måste använda offentligt tillgängliga typer för sina parametrar och returvärden. Mer information finns i Åtkomstmodifierare.

Följande kodfragment visar dessa fel:

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
}

Om du vill åtgärda dessa fel kontrollerar du att alla typer som används i offentliga operatordeklarationer också är offentligt tillgängliga.

Användardefinierade konverteringsbegränsningar

• CS0552: Användardefinierad konvertering till/från-gränssnitt.
• CS0553: Användardefinierad konvertering till/från basklass.
• CS0554: Användardefinierad konvertering till/från härledd klass.
• CS0555: Användardefinierad operator kan inte ta ett objekt av den omslutande typen och konvertera till ett objekt av den omslutande typen.
• CS0556: Användardefinierad konvertering måste konverteras till eller från den omslutande typen.
• CS0557: Duplicera användardefinierad konvertering i typ.

Dessa fel uppstår när du försöker skapa ogiltiga användardefinierade konverteringsoperatorer. Konverteringsoperatorer har specifika begränsningar för vilka typer de kan konvertera mellan. Mer information finns i Användardefinierade konverteringsoperatorer. Följande kod visar föregående fel:

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

Åtgärda dessa fel genom att ta bort ogiltiga konverteringsoperatorer eller omstrukturera din typhierarki för att undvika de begränsade konverteringsmönstren.

Booleska operatorer och kortslutningsoperatorer

• CS0215: Returtypen för operatorn true eller false måste vara bool.
• CS0216: Operatorn kräver att en matchande operator också definieras.
• CS0217: För att kunna användas som kortslutningsoperator måste en användardefinierad logisk operator ha samma returtyp som typen av dess 2 parametrar.
• CS0218: Typen måste innehålla deklarationer av operatorn true och operator false.

Dessa fel uppstår när du definierar logiska operatorer felaktigt. Vissa operatorer måste definieras i par och kortslutningsoperatorer har specifika signaturkrav. Mer information finns i sant och falskt operatorer, booleska logiska operatorer och användardefinierade villkorsstyrda logiska operatorer. Följande kod visar dessa fel:

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

Om du vill åtgärda dessa fel måste du definiera obligatoriska kopplade operatorer och följa rätt signaturmönster för logiska operatorer.

Kontrollerade operatorer

• CS9023: Operatorn kan inte kontrolleras
• CS9024: Operatorn kan inte avmarkeras
• CS9025: Kontrollerad operator kräver att en motsvarande okontrollerad version också deklareras

Dessa fel uppstår när du felaktigt använder nyckelorden checked eller unchecked med operatordeklarationer. Alla operatorer stöder inte kontrollerade/avmarkerade varianter, och när de gör det måste vissa krav uppfyllas. Mer information finns i Aritmetiska operatorer och Användardefinierade kontrollerade operatorer.

Åtgärda dessa fel genom att antingen ta bort nyckelordet checked eller unchecked från operatorer som inte stöder det, eller se till att du anger både kontrollerade och icke-kontrollerade versioner när det behövs.

Gränssnitts- och arvskrav

• CS9311: Typen implementerar inte gränssnittsmedlem. Typen kan inte implementera medlem eftersom en av dem inte är en operator
• CS9312: Typen kan inte åsidosätta ärvd medlem eftersom en av dem inte är en operator
• CS9313: Överlagrad sammansatt tilldelningsoperator tar en parameter

Dessa fel uppstår när det finns felmatchningar mellan operatordeklarationer och gränssnittsimplementeringar eller arvsrelationer. Operatorer har specifika regler för implementering av gränssnitt och överskrivning. Mer information finns i Överlagring av operatorer och gränssnitt.

Åtgärda dessa fel genom att se till att operatörsdeklarationerna överensstämmer korrekt med gränssnittskraven och följer reglerna för operatoröverlagring och sammansatta tilldelningsoperatorer.

Likhetsoperatorer

• CS0660: Typ definierar operatorn == eller operatorn != men åsidosätter inte Object.Equals(object o)
• CS0661: Typ definierar operatorn == eller operatorn != men åsidosätter inte Object.GetHashCode()

Dessa varningar inträffar när du definierar likhets- eller ojämlikhetsoperatorer utan att åsidosätta motsvarande metoder från Object. När du definierar en anpassad jämförelse för likhet bör du också åsidosätta Object.Equals och Object.GetHashCode för att säkerställa konsekvent beteende. Mer information finns i Definiera värdejämlikhet för en typ och likhetsoperatorer.

Om du vill åtgärda dessa varningar åsidosätter du både Equals och GetHashCode när du definierar anpassade likhetsoperatorer.