Os extension methods permitem a criação de métodos tipados sem a necessidade de se criar tipos derivados, recompilar e/ou modificar o tipo original.

Vale lembrar que extension methods são uma novidade do Framework .Net 3.5.

Estes são métodos estáticos especiais que são chamados pelas variáveis dos tipos as quais foram criados para atender.

Na prática, um extension method permite (por exemplo) que seja criado um método (VerificaSeEhEmail()) que pode ser utilizado por todas as variáveis do tipo string (texto).

Desta forma, teríamos algo como:

string enderecoEmail = “meuEmail@meuservidor.com.br”;
bool ehEmail = enderecoEmail.VerificaSeEhEmail();

Isso é especialmente útil para a substituição das enormes quantidades de classes helper que todos criam e cedo ou tarde elas próprias se tornam perdidas nos projetos.

Em diversas simulações que nós do DotNetMax fizemos, conseguimos usar um WebServices dentro do extension method, isso tudo da forma como se normalmente usa WebServices, ou seja, sem mágicas.

Construindo o Extension Method

Um extension method sempre é estático e declara o tipo a qual ele pertence. Em nosso exemplo será do tipo “String”:

public static [TipoDoRetorno] [NomeDoMetodo](this [TipoAQualPertence] [nomedoParametro])
{
}

Em C#:

public static bool IsEmailValid(this String str)
{
    return RunRegEx(str, Email);
}

Os extension methods devem ficar dentro de um namespace e uma classe (o nome da classe não importa para nada, o que é mandatório é o namespace). “Para usar o extension method, na classe ”.cs” aonde será usado, o namespace deve ser importado.

Classe de Exemplos

namespace DotNetMax.StringMethods
{
    public static class HelpersString
    {
        ///
        /// Contém a Expressão Regular para a Validação de CPF
        ///
        /// Validação para os Formatos: XXX.XXX.XXX-XX ou XXXXXXXXXXX
        private const string CPF = @"\d{3}.?\d{3}.?\d{3}-?\d{2}";

        ///
        /// Contém a Expressão Regular para a Validação de CNPJ
        ///
        /// Validação para os Formatos: XX.XXX.XXX/XXXX-XX ou XXXXXXXXXXXXXX
        private const string CNPJ = @"\d{2}.?\d{3}.?\d{3}/?\d{4}-?\d{2}";

        ///
        /// Contém a Expressão Regular para a Validação de CEP
        ///
        /// Validação para o Formato XXXXX-XXX
        private const string CEP = @"\d{5}-\d{3}";

        ///
        /// Contém a Expressão Regular para a Validação de Email
        ///
        private const string Email = @"^([0-9a-zA-Z]([-.\w]*[0-9a-zA-Z])*@(([0-9a-zA-Z])+([-\w]*[0-9a-zA-Z])*\.)+[a-zA-Z]{2,9})$";

        ///
        /// Verifica se a String é um CNPJ Válido (Apenas Máscara)
        ///
        public static bool ISCEPValido(this String str)
        {
            return RunRegEx(str, CEP);
        }

        ///
        /// Verifica se a String é um CNPJ Válido (Apenas Máscara)
        ///
        public static bool ISCNPJValido(this String str)
        {
            return RunRegEx(str, CNPJ);
        }

        ///
        /// Verifica se a String é um CPF Válido (Apenas Máscara)
        ///
        public static bool ISCPFValido(this String str)
        {
            return RunRegEx(str, CPF);
        }

        ///
        /// Verifica se a String é um Email Válido
        ///
        public static bool IsEmailValid(this String str)
        {
            return RunRegEx(str, Email);
        }

        ///
        /// Executa uma RegEx
        ///
        private static bool RunRegEx(string source, string regexPattern)
        {
            // Create Objects
            Regex regExEngine;

            // Inicializa o Engine de RegEx
            regExEngine = new Regex(regexPattern);

            // Verifica se Passa
            return regExEngine.IsMatch(source);
        }
    }
}

Usando o Exemplo

Para o exemplo usamos uma console application.

using System;
using System.Text.RegularExpressions;
using DotNetMax.StringMethods;

namespace ConsoleApplication4
{
    class Program
    {
        static void Main(string[] args)
        {
            // Criando as Variáveis
            string enderecoDeEmailDoUsuario = "endereco@provedor.com.br"; // Válido
            string cpfDoUsuario = "123.456.789-00"; // Válido
            string cnpjDaEmpresa = "123.456.789.789-98/00"; // Inválido

            // Usando os Métodos
            bool emailEhValido = enderecoDeEmailDoUsuario.IsEmailValid();
            bool cpfEhValido = cpfDoUsuario.ISCPFValido();
            bool cnpjEhValido = cnpjDaEmpresa.ISCNPJValido();
        }
    }
}

Observe primeiramente que o namespace dos extension methods foi importado (DotNetMax.StringMethods)

Potenciais e Variações

Em nossos exemplos utilizamos o tipo “string”, mas nada impede de se fazer para tipos mais complexos de objetos e até mesmo interfaces.

Esses exemplos contêm apenas códigos para validações de texto, mas podem ser feitos para números, datas, objetos de formulário (grids, combos, textbox), tipos de coleção e até para LINQ.

Você pode colocar os extension methods em projetos específicos para isso e distribuir o binário para toda a equipe de desenvolvimento.

Explore o potencial dessa tecnologia que ao meu ver tem muito a oferecer.

Posts Relacionados:

1. Algoritmo para Validação de CPF
2. Convertendo String Delimitada por Tamanho (Trancode) em Array
3. Tipos Nulos (Nullable Value Types)
4. Abrindo Arquivos de Texto e Lendo Todo o Conteúdo
5. Reflection Parte 2 – Construtores
6. Manipulando Arquivos e Diretórios no .NET
7. Calculando CRC de Strings (Texto), Array’s e Arquivos