Métodos de extensão permitem "adicionar" métodos a tipos existentes (incluindo tipos que você não possui, como string ou int) sem modificá-los ou herdar deles. Eles são definidos como métodos estáticos com um modificador this no primeiro parâmetro, e chamados como se fossem métodos de instância. O LINQ é construído sobre eles.
public static class StringExtensions
{
// `this string str` makes this an extension method ON string
public static bool IsValidEmail(this string str)
{
return str.Contains("@") && str.Contains(".");
}
public static string Truncate(this string str, int max)
{
return str.Length <= max ? str : str[..max] + "...";
}
}
// call them as if they were instance methods on string
"[email protected]".IsValidEmail(); // true
"long text here".Truncate(5); // "long ..."
O modificador this no primeiro parâmetro marca o método como uma extensão daquele tipo. É um método estático, mas você o chama como um método de instância (str.IsValidEmail()), o que é natural de ler.
// these are equivalent — the extension call is sugar for a static call
"[email protected]".IsValidEmail();
StringExtensions.IsValidEmail("[email protected]");
Métodos de extensão são mágica do compilador — são realmente chamadas a métodos estáticos, mas a sintaxe de parâmetro this permite que você os chame fluentemente como se pertencessem ao tipo. (Eles devem estar em uma classe estática e o namespace importado com using.)
// Where, Select, OrderBy, etc. are extension methods on IEnumerable<T>
list.Where(x => x > 0).Select(x => x * 2);
// → IEnumerable<T> has no Where method; LINQ ADDS them via extension methods
Todos os operadores de consulta do LINQ (Where, Select, etc.) são métodos de extensão em IEnumerable<T> — é por isso que eles se encadeiam tão fluentemente. Este é o uso mais proeminente de métodos de extensão.
Métodos de extensão são uma característica importante e distintiva do C#, e compreendê-los é valioso tanto para usá-los quanto para entender como as partes-chave do C# funcionam — mais notavelmente o LINQ, que é totalmente construído em métodos de extensão (os operadores Where/Select/OrderBy são extensões em IEnumerable<T>, é por isso que eles se encadeiam tão fluentemente).
O recurso permite adicionar funcionalidade a tipos existentes — incluindo aqueles que você não possui (string, int, tipos de framework) ou não pode modificar (classes seladas, interfaces) — sem herança ou modificação do original, mantendo uma sintaxe de chamada limpa e fluente (str.IsValidEmail() lê como um método de instância).
Isso é útil para escrever métodos auxiliares que estendem tipos naturalmente, construir APIs fluentes e adicionar comportamento a interfaces.
Compreender métodos de extensão — como defini-los (this no primeiro parâmetro, em uma classe estática), que eles são açúcar sintático para chamadas estáticas, e especialmente que o LINQ é construído sobre eles — é conhecimento importante tanto para escrever auxiliares C# limpos e fluentes quanto para entender como o LINQ e muitas APIs fluentes do .NET conseguem sua sintaxe.
Como métodos de extensão sustentam uma das características mais importantes do C# (LINQ) e são uma forma comum de estender tipos elegantemente, conhecê-los é conhecimento frequentemente aplicado que reflete compreensão de como as APIs fluentes e extensíveis do C# funcionam — e permite escrever código igualmente limpo e descobrível.