Vitor Ricardo

Sobrecarga C#

Sobrecarga (Overload) é o nome dado ao ato de se criar vários métodos, procedimento ou propriedades com o mesmo nome, porém, com parâmetros diferentes.

Mas qual o motivo de se fazer isso? Vamos supor que você crie uma classe útil que terá funções de cálculos e de escrita, e para abranger a maior quantidade de possibilidades de entrada de dados, você tenha que criar vários métodos, exemplo:

public int SomarInteiro(int a, int b) {
    return a+b;
}

public int SomarString(string valor1, string valor2)
{
    return Convert.ToInt32(valor1) + Convert.ToInt32(valor2);
}

Os nomes de suas funções ficariam um tanto quanto estranhas com o tempo, certo? Pense, caso queira adicionar um terceiro parâmetro para a soma, como ficaria? Somar3Inteiros()? Desse jeito não rola…

Então, vamos para as sobrecargas! Crie um projeto e adicione uma classe chamada Util.cs, dentro dela, cole o seguinte código:

/// <summary>
/// Método usado para somar 2 valores int
/// </summary>
/// <param name="valor1"></param>
/// <param name="valor2"></param>
/// <returns></returns>
public static int Somar(int valor1, int valor2)
{
    return valor1 + valor2;
}

/// <summary>
/// Método usado para somar 2 valores int
/// </summary>
/// <param name="valor1"></param>
/// <param name="valor2"></param>
/// <returns></returns>
public static int Somar(string valor1, string valor2)
{
    return Convert.ToInt32(valor1) + Convert.ToInt32(valor2);
}

/// <summary>
///  Método usado para somar 3 valores float
/// </summary>
/// <param name="valor1"></param>
/// <param name="valor2"></param>
/// <param name="valor3"></param>
/// <returns></returns>
public static float Somar(float valor1, float valor2, float valor3)
{
    return valor1 + valor2 + valor3;
}

Até o momento temos 3 métodos chamados Somar que recebem parâmetros diferentes de entrada e também devolvem parâmetros diferentes ao serem executados.

Agora, adicione o seguinte trecho ainda no mesmo arquivo:

/// <summary>
/// Método usado para escrever uma string
/// </summary>
/// <param name="texto"></param>
public static void Escrever(string texto)
{
    Console.WriteLine(texto);
}

/// <summary>
/// Método usado para escrever um float
/// </summary>
/// <param name="valor1"></param>
public static void Escrever(float valor1)
{
    Console.WriteLine(valor1);
}

/// <summary>
/// Método usado para escrever um int
/// </summary>
/// <param name="valor1"></param>
public static void Escrever(int valor1)
{
    Console.WriteLine(valor1);
}

Aí estão mais alguns métodos que recebem parâmetros diferentes, porém, esses não devolvem nada. Enfim, vamos testar esses códigos, abra o arquivo Program.cs, e adicione o seguinte trecho no método Main:

//Soma 2 número int
int soma1 = Util.Somar(10, 50);
//Soma 2 números em string
int soma2 = Util.Somar("100", "89");
//Soma 3 números do tipo float
float soma3 = Util.Somar(25.6f, 36.7f, 99.7456f);

//Escreve um int
Util.Escrever(soma1);
//Escreve uma string
Util.Escrever($"Resultado soma2: {soma2}");
//Escreve um float
Util.Escrever(soma3);

//Escreve um int, mas soma 2 int antes
Util.Escrever(Util.Somar(15,74));

//Escreve um float, mas soma 3 float antes
Util.Escrever(Util.Somar(5, 15, 45));

//Outputs:
//60
//Resultado soma2: 189
//162,0456
//89
//65

Acima temos exemplos de como se usar o método Somar, vemos como melhora a visualização do código desta maneira, ele fica muito mais legível.

Dica: crie funções mais complexas, exija classes como parâmetros, retornem classes em seus métodos. Treinem!

Conclusão

O uso da sobrecarga ou overload permite que vários métodos do mesmo nome recebam parâmetros diferentes e consequentemente possam retornar valores diferentes. Devido a isso, a organização da escrita do seu código melhora, o que o torna mais legível e facilita encontrar ele nas sugestões de métodos do Visual Studio.

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *