Entendendo e utilizando métodos de extensão em C#

Métodos de instância definidos

Em C#, um método é definido dentro de uma classe. A sintaxe geral para a definição de um método inclui um modificador de acesso, tipo de retorno, nome do método e parâmetros.

public class SampleClass
{
    public void SampleMethod()
    {
        // Method implementation  
    }
}

public class SampleClass
{
    public void SampleMethod()
    {
        // Method implementation  
    }
}

No exemplo de Tim Corey, aos 4:05, ele define um método dentro de uma classe estática para criar um método de extensão. O método definido é PrintToConsole. A definição inclui toda a sintaxe geral, explicando claramente como definir um método com um exemplo prático:

public static class Extensions
{
    public static void PrintToConsole(this string message)
    {
        Console.WriteLine(message);
    }
}

public static class Extensions
{
    public static void PrintToConsole(this string message)
    {
        Console.WriteLine(message);
    }
}

Chamando um método

Uma 'chamada de método' instrui o programa a executar um método específico definido em outra parte do código, realizando uma ação predefinida. Os métodos são chamados usando a instância da classe ou diretamente, se forem métodos estáticos. Para métodos de extensão, eles aparecem como se fizessem parte do tipo que estendem. No vídeo, aos 6:18, Tim mostra como chamar um método de extensão com um tipo de dado primitivo, assim como seus métodos predefinidos.

string demo = "This is a demo";
demo.PrintToConsole(); // Extension method call

string demo = "This is a demo";
demo.PrintToConsole(); // Extension method call

Parâmetros

Os parâmetros são especificados na definição do método e funcionam como marcadores para os valores que são passados ​​para o método. Você pode ver isso aqui após o método WriteLine ser chamado, onde message é o parâmetro.

public void DisplayMessage(string message)
{
    Console.WriteLine(message);
}

public void DisplayMessage(string message)
{
    Console.WriteLine(message);
}

Novamente, no exemplo do método de extensão que Tim Corey deu às 4:05, message é o parâmetro:

public static void PrintToConsole(this string message)
{
    Console.WriteLine(message);
}

public static void PrintToConsole(this string message)
{
    Console.WriteLine(message);
}

Argumentos

Os argumentos são os valores reais passados ​​para o método quando ele é chamado.

DisplayMessage("Hello, World!"); // "Hello, World!" is the argument

DisplayMessage("Hello, World!"); // "Hello, World!" is the argument

Quando Tim Corey chama o método às 6:20 usando a sintaxe de ponto com o tipo string, o valor da string está, na verdade, sendo passado como um valor para o método PrintToConsole:

string demo = "This is a demo";
demo.PrintToConsole(); // "This is a demo" is the argument

string demo = "This is a demo";
demo.PrintToConsole(); // "This is a demo" is the argument

O que são métodos de extensão? (3:13)

Os métodos de extensão permitem adicionar novos métodos a tipos existentes sem precisar modificá-los ou recompilá-los. Embora sejam chamados como se fossem métodos de instância, os métodos de extensão são definidos como estáticos.

Criando um método de extensão

Na seção anterior, "Definindo e Chamando Métodos", destacamos como Tim Corey criou um método de extensão em uma classe estática separada e definiu o método estático dentro dela para ser usado como um método de extensão. Aqui estão alguns pontos-chave que Tim Corey destaca:

1. Certifique-se de definir uma classe pública estática separada ou, como Tim diz, "marque a classe como estática, caso contrário, não funcionará".
2. À medida que você cria mais métodos de extensão, agrupe-os por tipo (3:43)
3. Defina um método estático com o primeiro parâmetro prefixado com a palavra-chave this, especificando o tipo a ser estendido (4:58)

public static class Extensions
{
    public static void PrintToConsole(this string message)
    {
        Console.WriteLine(message);
    }
}

public static class Extensions
{
    public static void PrintToConsole(this string message)
    {
        Console.WriteLine(message);
    }
}

Chamando o método de extensão (6:18)

Em seguida, Tim mostra como chamar um método de extensão nessa variável de string:

demo.PrintToConsole();

demo.PrintToConsole();

Quando você insere demo e começa a digitar Print, o IntelliSense sugere o método PrintToConsole. Este é o novo método adicionado ao tipo string.

Como funciona a chamada de método (6:30)

Tim explica por que você pode chamar demo.PrintToConsole():

• Demo é um Tipo String: A variável demo é do tipo string.
• Tipo String Estendido: O tipo string foi estendido com o novo método PrintToConsole.

Entendendo o Parâmetro (6:41)

Embora pareça que nenhum parâmetro está sendo passado para o método PrintToConsole, Tim aponta a passagem de parâmetro implícita - a string demo é passada como o primeiro parâmetro para o método de extensão.

Tim enfatiza que os métodos de extensão têm um parâmetro a menos na chamada do que na sua definição. Isso ocorre porque o primeiro parâmetro (o tipo que está sendo estendido) é implícito.

Assinatura do método de extensão

Aqui, this string message significa que o método estende o tipo string, e message é o parâmetro implícito:

public static void PrintToConsole(this string message)

public static void PrintToConsole(this string message)

Executando o código (7:08)

Finalmente, quando o método PrintToConsole é chamado, ele imprime a string no console:

Console.WriteLine(message);

Console.WriteLine(message);

Assim, chamar demo.PrintToConsole() imprime "This is a demo" no console.

Extensão de classes de terceiros (10:59)

Tim Corey explica que os métodos de extensão podem estender qualquer tipo, inclusive classes de terceiros que você não pode modificar diretamente. Por exemplo, vamos dar uma olhada na classe SimpleLogger às 11:09.

Aqui, Tim usa a classe hipotética de terceiros SimpleLogger que registra mensagens no console (11:09). A classe possui dois métodos:

public class SimpleLogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }

    public void Log(string message, string messageType)
    {
        Console.WriteLine($"{messageType}: {message}");
    }
}

public class SimpleLogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }

    public void Log(string message, string messageType)
    {
        Console.WriteLine($"{messageType}: {message}");
    }
}

Esses métodos não são ideais porque o tipo de mensagem é uma simples string, o que pode levar a inconsistências. Tim sugere a criação de métodos de extensão para melhorar a classe.

Implementando tipos de mensagens consistentes

O uso de métodos de extensão garante a consistência do seu código, utilizando sempre os mesmos tipos de mensagem e formatação. Aqui em (12:40), Tim cria uma classe estática ExtendSimpleLogger:

public static class ExtendSimpleLogger
{
    public static void LogError(this SimpleLogger logger, string message)
    {
        logger.Log(message, "Error");
    }

    public static void LogWarning(this SimpleLogger logger, string message)
    {
        logger.Log(message, "Warning");
    }
}

public static class ExtendSimpleLogger
{
    public static void LogError(this SimpleLogger logger, string message)
    {
        logger.Log(message, "Error");
    }

    public static void LogWarning(this SimpleLogger logger, string message)
    {
        logger.Log(message, "Warning");
    }
}

Tornando as chamadas mais consistentes

Com ela em mãos, (14:02) ele agora é capaz de chamar os métodos de extensão em uma instância SimpleLogger:

SimpleLogger logger = new SimpleLogger();
logger.LogError("This is an error");
logger.LogWarning("This is a warning");

SimpleLogger logger = new SimpleLogger();
logger.LogError("This is an error");
logger.LogWarning("This is a warning");

Isso garante que os tipos de mensagem sejam sempre 'Erro' e 'Aviso'.

Aprimorando a formatação de saída (14:35)

Tim adiciona uma funcionalidade para definir a cor do texto do console para mensagens de erro, garantindo que elas se destaquem:

public static void LogError(this SimpleLogger logger, string message)
{
    var defaultColor = Console.ForegroundColor;
    Console.ForegroundColor = ConsoleColor.Red;
    logger.Log(message, "Error");

    Console.ForegroundColor = defaultColor;
}

public static void LogError(this SimpleLogger logger, string message)
{
    var defaultColor = Console.ForegroundColor;
    Console.ForegroundColor = ConsoleColor.Red;
    logger.Log(message, "Error");

    Console.ForegroundColor = defaultColor;
}

Comparação com chamadas de método diretas (17:21)

Tim compara essa abordagem a chamar diretamente os métodos originais Log, o que poderia levar a inconsistências:

logger.Log("Test error", "Error");
logger.Log("Another error", "ERROR");

logger.Log("Test error", "Error");
logger.Log("Another error", "ERROR");

Essa abordagem é propensa a erros de digitação e formatação inconsistente.

Métodos de extensão de encadeamento (18:13)

Tim demonstra como os métodos de extensão podem ser encadeados para tornar o código mais legível:

public static void LogInfo(this SimpleLogger logger, string message)
{
    logger.Log(message, "Info");
}

public static void SaveToDatabase(this SimpleLogger logger)
{
    // Simulate saving to a database
}

public static void LogInfo(this SimpleLogger logger, string message)
{
    logger.Log(message, "Info");
}

public static void SaveToDatabase(this SimpleLogger logger)
{
    // Simulate saving to a database
}

Agora, você pode encadear esses métodos:

logger.LogInfo("Information").SaveToDatabase();

logger.LogInfo("Information").SaveToDatabase();

Isso torna o código mais legível e intuitivo em comparação com chamadas de métodos aninhadas:

SaveToDatabase(LogInfo(logger, "Information"));

SaveToDatabase(LogInfo(logger, "Information"));

Ao usar a notação de ponto e encadeamento, a intenção do código fica mais clara e menos aninhada.

Ampliando coisas que você não possui

Aos 20:13, Tim Corey explica que os métodos de extensão são ideais para adicionar funcionalidades a classes que não lhe pertencem, como bibliotecas de terceiros. Isso permite melhorias sem modificar o código original.

Evitando dependências

Corey também destaca o uso de métodos de extensão para introduzir dependências sem acoplá-las diretamente a uma classe. Por exemplo, adicionar funcionalidade de salvamento em banco de dados a uma classe Person sem incorporar lógica de banco de dados.

Extensão de interfaces

Os métodos de extensão também podem ser aplicados a interfaces, como explicado a partir de 21:30, permitindo que várias classes que implementam a interface compartilhem a mesma funcionalidade. Isso promove a reutilização e a simplificação do código.

Quando não usar métodos de extensão

Às 23:03, Tim Corey desaconselha o uso excessivo de métodos de extensão, especialmente com tipos primitivos ou fornecidos pela Microsoft, para evitar confusão e complexidade. Use-os com moderação e somente quando oferecerem benefícios claros.

O princípio aberto/fechado

Na seção entre 24:54 e 25:40, Tim enfatiza a importância de seguir o princípio aberto/fechado, utilizando métodos de extensão para adicionar novas funcionalidades sem modificar o código existente e estável, reduzindo assim o risco de introduzir erros.

Melhores práticas para o uso de declarações

Organize os métodos de extensão agrupando-os logicamente e colocando-os em namespaces separados para evitar conflitos de nomes e facilitar a manutenção e a depuração.