Dando continuidade a nossa série, vamos falar de um dos novos recursos com maior expressão na linguagem e no .NET 3.5, a possibilidade de criar métodos de extensão (extension methods).

Extension Methods, são métodos estáticos que podemos utilizar para estender funcionalidades de classes especificas do .NET.

Declarando um Extension Method

Para declararmos novos métodos de extensão, primeiro precisamos saber que o funcionamento dos métodos é semelhante aos métodos estáticos, portanto, você só pode declará-los em classes estáticas. Segundo, sempre que formos declarar um extension method, vamos especificar a palavra-chave this como primeiro parâmetro do método. Vamos ver um exemplo:

 

namespace ExtensionMethods
{

    public static class ExtMethods
    {
        //Static Method - Maneira tradicional
        public static int ConvertInt32Static(string s)
        {
            return Int32.Parse(s);
        }

        //Extension Method - Nova funcionalidade
        public static int ConvertInt32Ext(this string s)
        {
            return Int32.Parse(s);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            //Valor
            string Valor = “9″;
            //Executando um extension method
            int ExtMethod = Valor.ConvertInt32Ext();

            //Excutando um Static Method
            int StaticMethod = ExtMethods.ConvertInt32Static(Valor);

            //Exibe os valores
            Console.WriteLine(“Extension Method: ” + ExtMethod);
            Console.WriteLine(“Static Method: ” + StaticMethod);
            Console.ReadLine();
        }
    }
}

 

Podemos notar no exemplo a diferença de comportamento entre um método estático e o novo extension method. Repare que devido a declaração da palavra this antes do parâmetro do método de extensão, o .NET Framework “incorporou” o método à classe string. Podemos notar a presença mais exata do método extensivo na classe através IntelliSense, com mostrado abaixo:

 

Agora vamos enumerar as diferenças entre os métodos estáticos (Static Methods) e os métodos de extensão (Extension Methods):

• Para declaração de métodos de extensão (Extension Methods) precisamos declarar antes do primeiro parâmetro a palavra-chave this. Já para os métodos estáticos (Static Methods) não temos a palavra.
• Quando consumimos um método de extensão, o parâmetro declarado no método é omitido, como podemos notar no primeiro exemplo. No método estático precisamos especificar o valor como parâmetro.
• Métodos de Extensão só podem ser declarados em classes estáticas, o que não é exigência para métodos estáticos.

Trabalhando por dentro do IL

Se formos olhar e analisar o IL gerado pela aplicação mostrada no exemplo 1 temos a seguinte informação:

 
Abaixo temos o código IL do método de extensão o ConvertInt32Ext.

.method public hidebysig static int32  ConvertInt32Ext(string s) cil managed
{
  .custom instance void 

  [System.Core]System.Runtime.CompilerServices.ExtensionAttribute::.ctor() = ( 01 00 00 00 )
  // Code size       12 (0xc)
  .maxstack  1
  .locals init ([0] int32 CS$1$0000)
  IL_0000:  nop
  IL_0001:  ldarg.0
  IL_0002:  call       int32 [mscorlib]System.Int32::Parse(string)
  IL_0007:  stloc.0
  IL_0008:  br.s       IL_000a
  IL_000a:  ldloc.0
  IL_000b:  ret
} // end of method ExtMethods::ConvertInt32Ext

Podemos notar no código grifado de vermelho a presença do atributo no método declarando-o como extension method.

E agora o código IL do método estático ConvertInt32Static.

.method public hidebysig static int32  ConvertInt32Static(string s) cil managed
{
  // Code size       12 (0xc)
  .maxstack  1
  .locals init ([0] int32 CS$1$0000)
  IL_0000:  nop
  IL_0001:  ldarg.0
  IL_0002:  call       int32 [mscorlib]System.Int32::Parse(string)
  IL_0007:  stloc.0
  IL_0008:  br.s       IL_000a
  IL_000a:  ldloc.0
  IL_000b:  ret
} // end of method ExtMethods::ConvertInt32Static

Porque usar Extension Methods?

Bom, depois de tudo isso você pode estar se perguntando… Porque usar os métodos de extensão?

Simples, por absoluta conveniência.

Vamos explicar melhor , suponha que você tenha passado anos desenvolvendo um Framework com funções usuais no dia a dia e que você quis disponibilizar a classe para uso externo. Quando alguém quiser consumir alguma função dela o desenvolvedor necessitará conhecer o nome da classe completo para poder executar o método estático desejado, algo como no exemplo abaixo:

Varivel = MeuFramework.

Neste ponto teremos o IntelliSense que lhe fornecerá todas as funções disponíveis, bastando você escolher a sua e fornecer os parâmetros necessários.

Varivel = MeuFramework.FuncaoDesejada(Valor);

Conclusão

Os extension methods nasce como um novo mecanismo para invocar métodos estáticos em objetos instanciados.

Até o próximo.