Dela via

Lösa fel och varningar i användardefinierade operatordeklarationer

Den här artikeln beskriver följande kompilatorfel:

  • 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.
  • CS9340: Operatorn kan inte tillämpas på operander. Den närmaste oanvändbara kandidaten visas.
  • CS9341: Operatorn kan inte tillämpas på operand. Den närmaste oanvändbara kandidaten visas.
  • CS9342: Operatörsupplösningen är tvetydig mellan följande medlemmar.

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.
  • CS9340: Operatorn kan inte tillämpas på operander. Den närmaste oanvändbara kandidaten visas.
  • CS9341: Operatorn kan inte tillämpas på operand. Den närmaste oanvändbara kandidaten visas.
  • CS9342: Operatorresolutionen är tvetydig mellan följande medlemmar.

Om du vill deklarera operatorer med rätt signaturer följer du dessa krav för den specifika operatortypen. Mer information finns i Operatoröverlagring.

  • Returnera den innehållande typen (eller en härledd typ) från ++ och -- operatorer (CS0448).
  • Använd den innehållande typen som parameter för ++ och -- operatorer (CS0559).
  • Använd den innehållande typen som parameter för unary-operatorer (CS0562).
  • Inkludera den innehållande typen som minst en parameter i binära operatorer (CS0563).
  • Använd den innehållande typen som den första parametern och int som den andra parametern för skiftoperatorer (CS0564).
  • Deklarera inte operatorer i gränssnitt (CS0567). Gränssnitt får inte innehålla operatorimplementeringar.
  • Returnera en icke-void typ från de flesta operatorer (CS0590), förutom vissa operatorer som kräver att man returnerar specifika värden (CS9310).
  • Ange operatoröverlagringar som accepterar rätt parametertyper för att undvika lösningsfel (CS9340, CS9341).
  • Åtgärda tvetydiga operatörsanrop genom att använda explicita typkonverteringar eller tillhandahålla mer specifika överlagrade metoder (CS9342).

Viktigt!

Signaturkraven för statiska binära operatorer och motsvarande instans sammansatta tilldelningsoperatorer skiljer sig åt. Kontrollera att signaturen matchar den deklaration du vill ha.

I följande exempel visas signaturfel:

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
}

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.

** För att deklarera operatorer korrekt, följ dessa krav för modifierare och innehållande typer. Mer information finns i Operatoröverlagring och Användardefinierade konverteringsoperatorer.

  • Deklarera operatorer med både static och public modifierare (CS0558, CS9308).
  • Deklarera inte operatorer i statiska klasser (CS0715). Använd vanliga klasser eller structs.
  • Använd giltiga, överlagbara operatorsymboler (CS1037).
  • Följ rätt syntax för konverteringsoperatorer: public static implicit/explicit operator <dest-type>(<source-type> parameter) (CS1553).
  • Se till att explicita gränssnittsimplementeringar av operatörer är static (CS8930) och public (CS8931).

I följande exempel visas deklarationsfel:

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
}

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'.

För att säkerställa konsekvent tillgänglighet i operatörsdeklarationer gör du alla typer som används i offentliga operatörer offentligt tillgängliga. Mer information finns i Åtkomstmodifierare.

  • Se till att returtyperna har minst samma åtkomstnivå som operatorn (CS0056).
  • Se till att parametertyperna har minst samma tillgänglighet som operatorn (CS0057).

När du deklarerar en public operator måste alla typer som används som parametrar eller returvärden också vara offentligt tillgängliga.

I följande exempel visas tillgänglighetsfel.

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
}

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.

Följ dessa begränsningar om du vill skapa giltiga användardefinierade konverteringsoperatorer. Mer information finns i Användardefinierade konverteringsoperatorer.

  • Definiera inte konverteringar till eller från gränssnitt (CS0552). Använd explicita gränssnittsimplementeringar i stället.
  • Definiera inte konverteringar till eller från basklasser (CS0553). Konverteringen finns redan genom arv.
  • Definiera inte konverteringar till eller från härledda klasser (CS0554). Konverteringen finns redan genom arv.
  • Definiera inte konverteringar från den omslutande typen till sig själv (CS0555). Den här konverteringen är implicit.
  • Se till att minst en typ i konverteringen är den omslutande typen (CS0556). Du kan inte definiera konverteringar mellan två externa typer.
  • Definiera inte duplicerade konverteringar (CS0557). Varje konverteringsoperator måste vara unik.

I följande exempel visas konverteringsbegränsningsfel:

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

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.

Om du vill definiera logiska operatorer korrekt följer du dessa krav för parkoppling och signatur. Mer information finns i sant och falskt operatorer, booleska logiska operatorer och användardefinierade villkorsstyrda logiska operatorer.

  • Returnera bool från operator true och operator false (CS0215).
  • Definiera obligatoriska parkopplade operatorer (CS0216):
    • operator == Kräver operator !=
    • operator < Kräver operator >
    • operator <= Kräver operator >=
    • operator true Kräver operator false
  • Matcha returtypen med parametertyperna för kortslutningsoperatorer (& och |) som fungerar med anpassade typer (CS0217).
  • Implementera både operator true och operator false när du använder anpassade typer i booleska kontexter som && och || (CS0218).

I följande exempel visas logiska operatorfel:

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

Kontrollerade operatorer

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

Följ dessa krav om du vill använda de kontrollerade operatorerna på rätt sätt. Mer information finns i Aritmetiska operatorer och Användardefinierade kontrollerade operatorer.

  • Använd checked eller unchecked nyckelord endast för aritmetiska operatorer som stöds: +, -, *, /, ++, --och explicita konverteringar (CS9023, CS9024).
  • Ange både markerade och avmarkerade versioner när du deklarerar en markerad operator (CS9025). Kompilatorn behöver båda hantera olika kontexter.

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

Följ dessa krav för att implementera och åsidosätta operatorer på rätt sätt. Mer information finns i Överlagring av operatorer och gränssnitt.

  • Se till att operatordeklarationerna matchar signaturen och typen av gränssnittsmedlemmar (CS9311). En operatör kan inte implementera en icke-operator-medlem.
  • Kontrollera att ärvda medlemmar som åsidosätts också är operatorer (CS9312). En operatör kan inte åsidosätta en icke-operatörmedlem.
  • Deklarera sammansatta tilldelningsoperatorer med en parameter (CS9313). Den vänstra operanden är implicit this.

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()

Om du vill implementera likhet korrekt åsidosätter du motsvarande Object metoder när du definierar anpassade likhetsoperatorer. Mer information finns i Definiera värdejämlikhet för en typ och likhetsoperatorer.

  • Åsidosätt Object.Equals när du definierar operator == eller operator != (CS0660).
  • Åsidosätt Object.GetHashCode när du definierar operator == eller operator != (CS0661).

Om du åsidosätter dessa metoder säkerställs konsekvent likhetsbeteende mellan olika API:er och samlingstyper.

  • Last updated on