Assinaturas e Sobrecarga em C#

Em C#, o conceito de assinatura é fundamental para a diferenciação entre métodos, construtores, indexadores e operadores, e permite a sobrecarga dessas funções. A sobrecarga é a capacidade de declarar vários métodos com o mesmo nome, mas com assinaturas diferentes, dentro de uma classe, struct ou interface. Neste artigo, vamos explorar como funcionam as assinaturas e a sobrecarga de membros em C#.

O Que é uma Assinatura?

Uma assinatura é uma combinação de elementos que identifica de maneira única um membro em C#. Para métodos, construtores, indexadores e operadores, a assinatura é composta pelos seguintes elementos:

• Métodos: A assinatura de um método inclui o nome, o número de parâmetros de tipo e o tipo e modo de passagem de cada parâmetro.
• Construtores: A assinatura de um construtor inclui o tipo e o modo de passagem de cada parâmetro.
• Indexadores: A assinatura de um indexador inclui o tipo de cada parâmetro, sem considerar o tipo de retorno.
• Operadores: A assinatura de um operador inclui o nome do operador e o tipo de cada parâmetro.

Um ponto importante é que as assinaturas não incluem o tipo de retorno, nomes de parâmetros, modificadores como params ou this, nem se os parâmetros são opcionais.

Exemplo de Sobrecarga de Métodos

A sobrecarga de métodos permite que múltiplos métodos com o mesmo nome sejam declarados, desde que suas assinaturas sejam únicas. Aqui está um exemplo:

class Calculadora
{
    public int Somar(int x, int y) => x + y; // Somar(int, int)
    public double Somar(double x, double y) => x + y; // Somar(double, double)
    public int Somar(int x, int y, int z) => x + y + z; // Somar(int, int, int)
}

Neste exemplo, o método Somar foi sobrecarregado três vezes, cada um com uma assinatura única. A assinatura dos métodos inclui o número e os tipos de parâmetros.

Regras de Sobrecarga

Em C#, é permitido sobrecarregar métodos, construtores, indexadores e operadores, desde que suas assinaturas sejam distintas. No entanto, algumas regras importantes se aplicam:

• Modificadores de Parâmetros: Modificadores como in, out, e ref fazem parte da assinatura. Métodos com a mesma assinatura, exceto por esses modificadores, não podem ser sobrecarregados. class Exemplo { public void Metodo(int x) {} public void Metodo(ref int x) {} // Válido, assinaturas diferentes public void Metodo(out int x) {} // Erro: 'out' e 'ref' não podem ser diferenciados na sobrecarga }
• Tipos de Retorno: O tipo de retorno não faz parte da assinatura, ou seja, não é possível sobrecarregar métodos apenas com base no tipo de retorno. class Exemplo { public int Metodo(string s) => 1; public string Metodo(string s) => "erro"; // Erro: mesmo nome e parâmetros }
• Uso de params: O modificador params também não é considerado parte da assinatura, então métodos que diferem apenas pela inclusão de params não podem ser sobrecarregados. class Exemplo { public void Metodo(string[] a) {} public void Metodo(params string[] a) {} // Erro: assinaturas são iguais }

Sobrecarga de Construtores

A sobrecarga de construtores segue as mesmas regras dos métodos. Vários construtores podem ser declarados, desde que tenham assinaturas diferentes.

class Pessoa
{
    public string Nome;
    public int Idade;

    public Pessoa(string nome) // Construtor 1
    {
        Nome = nome;
    }

    public Pessoa(string nome, int idade) // Construtor 2
    {
        Nome = nome;
        Idade = idade;
    }
}

Aqui, a classe Pessoa tem dois construtores sobrecarregados, um que aceita apenas o nome e outro que aceita o nome e a idade.

Sobrecarga de Operadores

Operadores também podem ser sobrecarregados, desde que suas assinaturas sejam únicas. Aqui está um exemplo:

class Complexo
{
    public int Real;
    public int Imaginario;

    public static Complexo operator +(Complexo c1, Complexo c2) => 
        new Complexo { Real = c1.Real + c2.Real, Imaginario = c1.Imaginario + c2.Imaginario };

    public static Complexo operator -(Complexo c1, Complexo c2) => 
        new Complexo { Real = c1.Real - c2.Real, Imaginario = c1.Imaginario - c2.Imaginario };
}

Aqui, os operadores + e - foram sobrecarregados para a classe Complexo.

Conclusão

As assinaturas são a base da sobrecarga de membros em C#. Sobrecargas permitem que diferentes versões de métodos, construtores, indexadores e operadores sejam criadas, contanto que suas assinaturas sejam distintas. É importante entender as regras de sobrecarga para garantir que o código esteja correto e funcione conforme esperado.