0Pricing
C# Academy · Aula

Definindo métodos de extensão

Escreva métodos estáticos com o modificador this.

Definindo métodos de extensão é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

O que é um método de extensão?

Um método de extensão permite adicionar novos métodos a um tipo existente sem modificá-lo nem criar um tipo derivado. Você o chama como se fosse um método de instância, mas ele é, na verdade, um método static especial.

As extensões são perfeitas quando você não é responsável pelo código-fonte de um tipo, como string ou int, mas quer oferecer a ele um novo comportamento conveniente.

Os três requisitos

Para declarar um método de extensão, você precisa de: uma classe estática, um método estático e um primeiro parâmetro marcado com a palavra-chave this. O parâmetro this especifica o tipo que você está estendendo.

using System;

public static class StringExtensions
{
    public static int WordCount(this string text)
    {
        if (string.IsNullOrWhiteSpace(text)) return 0;
        return text.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Length;
    }
}

public class Program
{
    public static void Main()
    {
        string sentence = "the quick brown fox";
        Console.WriteLine(sentence.WordCount());
    }
}

Chamando-o como um método de instância

Embora WordCount seja estático, você o chama como sentence.WordCount(). O compilador reescreve essa chamada internamente como StringExtensions.WordCount(sentence).

using System;
using System.Linq;

public static class StringExtensions
{
    public static string Repeat(this string text, int times)
    {
        return string.Concat(Enumerable.Repeat(text, times));
    }
}

public class Program
{
    public static void Main()
    {
        // These two lines do exactly the same thing
        Console.WriteLine("ab".Repeat(3));
        Console.WriteLine(StringExtensions.Repeat("ab", 3));
    }
}

O parâmetro this recebe a instância

O valor à esquerda do ponto se torna o parâmetro this. Você pode adicionar mais parâmetros depois dele, e quem chama o método passa esses parâmetros normalmente.

using System;

public static class IntExtensions
{
    public static bool IsBetween(this int value, int low, int high)
    {
        return value >= low && value <= high;
    }
}

public class Program
{
    public static void Main()
    {
        int age = 25;
        Console.WriteLine(age.IsBetween(18, 65));
        Console.WriteLine(10.IsBetween(1, 5));
    }
}

Estendendo seus próprios tipos

As extensões não servem apenas para tipos de bibliotecas. Você também pode estender suas próprias classes, o que é útil para manter um tipo central limpo e adicionar comportamentos auxiliares em outro lugar.

using System;

public class Money
{
    public decimal Amount { get; }
    public Money(decimal amount) { Amount = amount; }
}

public static class MoneyExtensions
{
    public static string ToUsd(this Money m) => "$" + m.Amount.ToString("0.00");
}

public class Program
{
    public static void Main()
    {
        var price = new Money(19.5m);
        Console.WriteLine(price.ToUsd());
    }
}

Extensões não podem acessar membros privados

Um método de extensão é apenas um método estático em outra classe, portanto só pode usar a superfície pública (ou interna, quando estiver no mesmo módulo) do tipo. Ele não pode acessar campos privados.

using System;

public class Counter
{
    private int _count;
    public int Value => _count;
    public void Increment() => _count++;
}

public static class CounterExtensions
{
    // Can only use public members like Value and Increment
    public static bool IsZero(this Counter c) => c.Value == 0;
}

public class Program
{
    public static void Main()
    {
        var c = new Counter();
        Console.WriteLine(c.IsZero());
        c.Increment();
        Console.WriteLine(c.IsZero());
    }
}

Encadeando métodos de extensão

Como cada extensão retorna um valor, você pode encadeá-las em um fluxo encadeado e fluente. Isso permite ler o código de cima para baixo e é o estilo usado pelo LINQ.

using System;

public static class TextExtensions
{
    public static string Shout(this string s) => s.ToUpper();
    public static string Bang(this string s) => s + "!";
}

public class Program
{
    public static void Main()
    {
        string result = "hello".Shout().Bang();
        Console.WriteLine(result);
    }
}

Nulo e métodos de extensão

Ao contrário de uma chamada de instância real, um método de extensão pode ser executado mesmo quando o receptor é null, porque nada é desreferenciado até que seu código acesse o receptor. Isso permite escrever auxiliares seguros para valores nulos.

using System;

public static class StringExtensions
{
    public static bool IsBlank(this string text)
    {
        // text may be null here, and that is fine
        return string.IsNullOrWhiteSpace(text);
    }
}

public class Program
{
    public static void Main()
    {
        string nothing = null;
        Console.WriteLine(nothing.IsBlank());
        Console.WriteLine("x".IsBlank());
    }
}

Métodos de instância têm prioridade sobre extensões

Se existir um método de instância real com uma assinatura correspondente, o compilador sempre dará preferência a ele em vez do método de extensão. As extensões apenas preenchem lacunas que o tipo ainda não cobre.

using System;

public static class Ext
{
    // This will be ignored because string already has ToString()
    public static string ToString(this string s, int n) => s + n;
}

public class Program
{
    public static void Main()
    {
        // Resolves to the built-in instance ToString(), not the extension
        Console.WriteLine("value: " + "abc".ToString());
    }
}

Uma biblioteca prática de auxiliares

Agrupar extensões relacionadas em uma única classe estática cria uma biblioteca de utilitários organizada. Esta é uma pequena classe auxiliar numérica que você pode reutilizar em vários projetos.

using System;

public static class NumberExtensions
{
    public static bool IsEven(this int n) => n % 2 == 0;
    public static int Squared(this int n) => n * n;
    public static double Percent(this int n) => n / 100.0;
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(4.IsEven());
        Console.WriteLine(5.Squared());
        Console.WriteLine(50.Percent());
    }
}

Experimente por conta própria

Combine o que você aprendeu: uma classe estática com várias extensões específicas, chamadas de forma fluente. É exatamente assim que as bibliotecas auxiliares usadas no dia a dia são criadas.

using System;

public static class StringExtensions
{
    public static string Capitalize(this string s)
        => string.IsNullOrEmpty(s) ? s : char.ToUpper(s[0]) + s.Substring(1);
    public static string Surround(this string s, char c) => c + s + c;
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine("hello".Capitalize().Surround('*'));
    }
}

Verificação rápida

Teste sua compreensão sobre a declaração de métodos de extensão.

Recapitulação

Você aprendeu que um método de extensão é um método static em uma classe static cujo primeiro parâmetro usa this. Ele é chamado com a sintaxe de instância, mas é compilado como uma chamada estática normal.

  • Três requisitos: classe estática, método estático e primeiro parâmetro this.
  • Somente membros públicos podem ser acessados.
  • Métodos de instância sempre têm prioridade.
  • As extensões podem ser encadeadas e até mesmo executadas em receptores null.

Perguntas Frequentes

A aula “Definindo métodos de extensão” é grátis?

Sim — o texto completo de “Definindo métodos de extensão” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “Definindo métodos de extensão”?

Escreva métodos estáticos com o modificador this. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Definindo métodos de extensão”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Definindo métodos de extensão
  2. Estendendo interfaces e genéricos
  3. Resolução de métodos de extensão
  4. Projetando boas extensões
← Voltar para C# Academy