Resolver erros e avisos em declarações de operador definidas pelo usuário

Este artigo aborda os seguintes avisos do compilador:

• CS0056: Acessibilidade inconsistente: o tipo de retorno 'type' tem acessibilidade menor do que o operador 'operator'
• CS0057: Acessibilidade inconsistente: o tipo de parâmetro 'type' é menos acessível que o operador 'operator'
• CS0215: O tipo de retorno do operador True ou False deve ser bool
• CS0216: O operador 'operator' requer que um operador correspondente 'missing_operator' também seja definido
• CS0217: para ser aplicável como um operador de curto-circuito, um operador lógico definido pelo usuário ('operador') deve ter o mesmo tipo de retorno que o tipo de seus dois parâmetros.
• CS0218: O tipo ('type') deve conter declarações do operador true e operador false
• CS0448: O tipo de retorno para o operador ++ ou -- deve ser o tipo contido ou derivado dele
• CS0552: 'rotina de conversão': conversão definida pelo usuário de/para interface
• CS0553: 'rotina de conversão': conversão definida pelo usuário para/da classe base
• CS0554: 'rotina de conversão': conversão definida pelo usuário de/para classe derivada
• CS0555: O operador definido pelo usuário não pode pegar um objeto do tipo delimitante e converter em um objeto do tipo delimitante
• CS0556: A conversão definida pelo usuário deve ser convertida para ou do tipo delimitador
• CS0557: conversão definida pelo usuário duplicada no tipo
• CS0558: o operador definido pelo usuário deve ser declarado estático e público
• CS0559: O tipo de parâmetro para o operador ++ ou -- deve ser o tipo contido
• CS0562: o parâmetro de um operador unário deve ser do tipo contido
• CS0563: Um dos parâmetros de um operador binário deve ser o tipo que contém
• CS0564: O primeiro operando de um operador de turno sobrecarregado deve ter o mesmo tipo que o tipo de contenção e o tipo do segundo operando deve ser int
• CS0567: As interfaces não podem conter operadores
• CS0590: Operadores definidos pelo usuário não podem retornar nulos
• CS0660: Tipo define operator == ou operator != mas não sobrescreve Object.Equals(object o)
• CS0661: o tipo define operator == ou operator !=, mas não substitui Object.GetHashCode()
• CS0715: classes estáticas não podem conter operadores definidos pelo usuário
• CS1037: Operador sobrecarregável esperado
• CS1553: a declaração não é válida; use 'operador modificador <tipo-destino> (...' em vez de
• CS8930: A implementação explícita de um operador definido pelo usuário deve ser estática.
• CS8931: a implementação explícita deve ser declarada pública para implementar o membro da interface no tipo.
• CS9023: O operador não pode ser controlado.
• CS9024: O operador não pode ser tornado sem verificação.
• CS9025: O operador requer que uma versão não verificada correspondente também seja declarada.
• CS9308: o operador definido pelo usuário deve ser declarado público.
• CS9310: O tipo de retorno para esse operador deve ser nulo.
• CS9311: o tipo não implementa o membro da interface. O tipo não pode implementar membro porque um deles não é um operador.
• CS9312: o tipo não pode substituir o membro herdado porque um deles não é um operador.
• CS9313: o operador de atribuição composta sobrecarregado usa um parâmetro.
• CS9340: O operador não pode ser aplicado a operandos. O candidato inaplicável mais próximo é mostrado.
• CS9341: O operador não pode ser aplicado ao operando. O candidato inaplicável mais próximo é mostrado.
• CS9342: a resolução do operador está ambígua entre os seguintes componentes.

Requisitos de assinatura do operador

• CS0448: o tipo de retorno para ++ ou -- operador deve ser o tipo que contém ou derivado do tipo que contém.
• CS0559: O tipo de parâmetro para ++ ou -- operador deve ser o tipo contido.
• CS0562: O parâmetro de um operador unário deve ser o tipo que o contém.
• CS0563: um dos parâmetros de um operador binário deve ser o tipo que contém.
• CS0564: O primeiro operando de um operador de turno sobrecarregado deve ter o mesmo tipo que o tipo de contenção e o tipo do segundo operando deve ser int.
• CS0567: as interfaces não podem conter operadores.
• CS0590: os operadores definidos pelo usuário não podem retornar nulos.
• CS9310: O tipo de retorno para esse operador deve ser nulo.
• CS9340: O operador não pode ser aplicado a operandos. O candidato inaplicável mais próximo é mostrado.
• CS9341: O operador não pode ser aplicado ao operando. O candidato inaplicável mais próximo é mostrado.
• CS9342: A resolução do operador é ambígua entre os seguintes membros.

Para declarar operadores com assinaturas corretas, siga esses requisitos para o tipo de operador específico. Para obter mais informações, consulte Sobrecarga de operador.

• Retorne o tipo de contenção (ou um tipo derivado) dos operadores ++ e -- (CS0448).
• Use o tipo de contenção como parâmetro para ++ e -- operadores (CS0559).
• Use o tipo de contenção como o parâmetro para operadores unários (CS0562).
• Inclua o tipo contendedor como pelo menos um parâmetro em operadores binários (CS0563).
• Use o tipo que contém como o primeiro parâmetro e int como o segundo parâmetro para operadores de turno (CS0564).
• Não declare operadores em interfaces (CS0567). As interfaces não podem conter implementações de operador.
• Retornar um tipo não nulo da maioria dos operadores (CS0590), exceto para operadores específicos que exigem void retornos (CS9310).
• Forneça sobrecargas de operador que aceitam os tipos de parâmetro corretos para evitar falhas de resolução (CS9340, CS9341).
• Desambiguar chamadas de operador usando conversões explícitas ou fornecendo sobrecargas mais específicas (CS9342).

O exemplo a seguir demonstra erros de assinatura:

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
}

Requisitos de declaração do operador

• CS0558: o operador definido pelo usuário deve ser declarado estático e público.
• CS0715: classes estáticas não podem conter operadores definidos pelo usuário.
• CS1037: operador sobrecarregado esperado.
• CS1553: A declaração não é válida; use 'operador modificador tipo destino<(>...' em vez disso.
• CS8930: A implementação explícita de um operador definido pelo usuário deve ser estática.
• CS8931: A implementação explícita deve ser declarada pública para implementar um membro de interface em um tipo.
• CS9308: o operador definido pelo usuário deve ser declarado público.

Para declarar corretamente os operadores, siga estes requisitos para modificadores e tipos contidos. Para obter mais informações, consulte Operador de sobrecarga e operadores de conversão definidos pelo usuário.

• Declare operadores com ambos static e public modificadores (CS0558, CS9308).
• Não declare operadores em classes estáticas (CS0715). Use classes ou structs regulares.
• Use símbolos de operador válidos, que podem ser sobrecarregados (CS1037).
• Siga a sintaxe correta para operadores de conversão: public static implicit/explicit operator <dest-type>(<source-type> parameter) (CS1553).
• Verifique se as implementações explícitas de interface dos operadores são static (CS8930) e public (CS8931).

O exemplo a seguir demonstra erros de declaração:

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
}

Acessibilidade inconsistente

• CS0056: Acessibilidade inconsistente: o tipo de retorno 'type' é menos acessível que o operador 'operator'.
• CS0057: Acessibilidade inconsistente: o tipo de parâmetro 'type' é menos acessível que o operador 'operator'.

Para garantir a acessibilidade consistente em declarações de operador, torne todos os tipos usados em operadores públicos acessíveis publicamente. Para obter mais informações, consulte Modificadores de Acesso.

• Verifique se os tipos de retorno têm pelo menos a mesma acessibilidade que o operador (CS0056).
• Verifique se os tipos de parâmetro têm pelo menos a mesma acessibilidade que o operador (CS0057).

Quando você declara um public operador, todos os tipos usados como parâmetros ou valores retornados também devem ser acessíveis publicamente.

O exemplo a seguir demonstra erros de acessibilidade:

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
}

Restrições de conversão definidas pelo usuário

• CS0552: Conversão de/para interface definida pelo usuário.
• CS0553: conversão definida pelo usuário para/da classe base.
• CS0554: conversão definida pelo usuário para/de classe derivada.
• CS0555: o operador definido pelo usuário não pode pegar um objeto do tipo delimitado e converter em um objeto do tipo delimitado.
• CS0556: a conversão definida pelo usuário deve ser convertida para ou do tipo delimitador.
• CS0557: conversão duplicada definida pelo usuário no tipo.

Para criar operadores de conversão definidos pelo usuário válidos, siga essas restrições. Para saber mais, confira Operadores de conversão definidos pelo usuário.

• Não defina conversões de ou para interfaces (CS0552). Em vez disso, use implementações de interface explícitas.
• Não defina conversões de ou para classes base (CS0553). A conversão já existe por meio da herança.
• Não defina conversões para ou de classes derivadas (CS0554). A conversão já existe por meio da herança.
• Não defina conversões do tipo delimitador para si mesmo (CS0555). Essa conversão está implícita.
• Verifique se pelo menos um tipo na conversão é o tipo encapsulador (CS0556). Você não pode definir conversões entre dois tipos externos.
• Não defina conversões duplicadas (CS0557). Cada operador de conversão deve ser exclusivo.

O exemplo a seguir demonstra erros de restrição de conversão:

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

Operadores booleanos e de curto-circuito

• CS0215: O tipo de retorno do operador true ou false deve ser bool.
• CS0216: O operador requer que um operador correspondente também seja definido.
• CS0217: Para ser aplicável como um operador de curto-circuito, um operador lógico definido pelo usuário deve ter o mesmo tipo de retorno que o tipo de seus dois parâmetros.
• CS0218: O tipo deve conter declarações de operador true e operador false.

Para definir os operadores lógicos corretamente, siga esses requisitos de emparelhamento e assinatura. Para obter mais informações, consulte operadores verdadeiros e falsos, operadores lógicos boolianos e operadores lógicos condicionais definidos pelo usuário.

• Retornar bool de operator true e operator false (CS0215).
• Definir operadores emparelhados necessários (CS0216):
  • operator == requer operator !=
  • operator < requer operator >
  • operator <= requer operator >=
  • operator true requer operator false
• Combinar o tipo de retorno com os tipos de parâmetro para operadores de curto-circuito (& e |) que funcionam com tipos personalizados (CS0217).
• Implemente ambos operator true e operator false ao usar tipos personalizados em contextos boolianos como && e || (CS0218).

O exemplo a seguir demonstra erros de operador lógico:

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

Operadores verificados

• CS9023: O operador não pode ser verificado
• CS9024: O operador não pode ser usado em modo não verificado
• CS9025: O operador verificado requer que uma versão não verificada correspondente também seja declarada

Para usar os operadores verificados corretamente, siga esses requisitos. Para obter mais informações, consulte operadores aritméticos e operadores verificados definidos pelo usuário.

• Aplicar checked ou unchecked palavras-chave somente a operadores aritméticos compatíveis: +, , -, *, /, , ++, --e conversões explícitas (CS9023, CS9024).
• Forneça versões marcadas e desmarcadas ao declarar um operador verificado (CS9025). O compilador precisa lidar com contextos diferentes.

Requisitos de interface e herança

• CS9311: O tipo não implementa o membro da interface. O tipo não pode implementar o membro porque um deles não é um operador
• CS9312: O tipo não pode substituir o membro herdado porque um deles não é um operador
• CS9313: O operador de atribuição composta sobrecarregado usa um parâmetro

Para implementar e substituir os operadores corretamente, siga esses requisitos. Para obter mais informações, consulte Sobrecarga do operador e interfaces.

• Verifique se as declarações do operador correspondem à assinatura e ao tipo de membros da interface (CS9311). Um operador não pode implementar um membro não operador.
• Verifique se os membros herdados que estão sendo substituídos também são operadores (CS9312). Um operador não pode substituir um membro não operador.
• Declare operadores de atribuição composta com um parâmetro (CS9313). O operando esquerdo é implicitamente this.

Operadores de igualdade

• CS0660: Tipo define operador == ou operador != mas não substitui Object.Equals(object o)
• CS0661: Tipo define operador == ou operador != mas não substitui Object.GetHashCode()

Para implementar a igualdade corretamente, substitua os métodos correspondentes Object ao definir operadores de igualdade personalizados. Para obter mais informações, consulte Como definir a igualdade de valor para um tipo e operadores de igualdade.

• Substituir Object.Equals ao definir operator == ou operator != (CS0660).
• Sobrescreva Object.GetHashCode quando você definir operator == ou operator != (CS0661).

Substituir esses métodos garante um comportamento de igualdade consistente entre diferentes APIs e tipos de coleção.