Sobrecarga de método

Muitas linguagens de programação suportam uma técnica chamada parâmetros padrão/opcionais. Ele permite que o programador torne um ou vários parâmetros opcionais, dando a eles um valor padrão. É especialmente prático ao adicionar funcionalidade ao código existente.

Por exemplo, você pode querer adicionar funcionalidade a uma função existente, o que requer que um ou mais parâmetros sejam adicionados. Ao fazer isso, você quebraria o código existente chamando essa função, já que eles não passariam a quantidade necessária de parâmetros. Para contornar isso, você poderia definir os parâmetros recém-adicionados como opcionais e dar a eles um valor padrão que corresponde a como o código funcionaria antes de adicionar os parâmetros.

Os parâmetros padrão foram introduzidos no C# versão 4.0, mas até então, os codificadores C# têm usado uma técnica diferente, que basicamente faz o mesmo, chamado sobrecarga de método. Ele permite que o programador defina vários métodos com o mesmo nome, desde que eles tomem um conjunto diferente de parâmetros. Quando você usa as classes do .NET framework, logo percebe que a sobrecarga de métodos é usada em todo o lugar. Um bom exemplo disso é o método Substring() da classe String. Tem uma sobrecarga extra, assim:

string Substring (int startIndex)
string Substring (int startIndex, int length)

Você pode chamá-lo com um ou dois parâmetros. Se você só o chamar com um parâmetro, o parâmetro length será assumido como o restante da string, economizando tempo sempre que quisermos simplesmente obter a última parte de uma string.

Então, definindo várias versões da mesma função, como evitamos ter o mesmo código em vários lugares? Na verdade, é bem simples: deixamos que as versões simples do método façam com que a versão complexa faça todo o trabalho. Considere o seguinte exemplo:

class SillyMath
{
    public static int Plus(int number1, int number2)
    {
        return Plus(number1, number2, 0);
    }

    public static int Plus(int number1, int number2, int number3)
    {
        return number1 + number2 + number3;
    }
}

Nós definimos um método Plus, em duas versões diferentes. O primeiro leva dois parâmetros, para adicionar dois números, enquanto a segunda versão leva três números. O trabalho real é feito na versão que leva três números - se quisermos apenas adicionar dois, chamamos a versão de três parâmetros e simplesmente usamos 0 como o terceiro parâmetro, agindo como um valor padrão. Eu sei, eu sei, é um exemplo tolo, como indicado pelo nome da classe, mas deve lhe dar uma idéia de como tudo funciona.

Agora, sempre que você sentir vontade de fazer matemática avançada adicionando um total de quatro números (apenas brincando), é muito simples adicionar uma nova sobrecarga:

class SillyMath
{
    public static int Plus(int number1, int number2)
    {
        return Plus(number1, number2, 0);
    }

    public static int Plus(int number1, int number2, int number3)
    {
        return Plus(number1, number2, number3, 0);
    }

    public static int Plus(int number1, int number2, int number3, int number4)
    {
        return number1 + number2 + number3 + number4;
    }
}

O legal disso é que todas as suas chamadas existentes para o método Plus continuarão funcionando, como se nada tivesse sido alterado. Quanto mais você usar o C#, mais aprenderá a apreciar a sobrecarga do método.