Reflection

Apesar de o C# se destacar por ser uma linguagem estática, de código gerenciado e fortemente tipada, volta e meia nos deparamos com a necessidade de acessar recursos que estão fora deste ambiente gerenciado, de uma forma um pouco mais dinâmica.

Essa não é uma necessidade nova, porém recentemente muito tem se falado de linguagens dinâmicas na plataforma .NET, como os IronPhyton e IronRuby, e até um Dynamic C#, que parece que vai estar aí na versão 4 da linguagem.Enquanto essas novidades não chegam e mostram serviço, a solução mais comum que temos para esse tipo de necessidade é o famoso Reflection do .NET.

O Reflection nos oferece uma forma de encapsularmos assemblies. Ou seja, você pode utilizar o Reflection para acessar um assembly que não esteja diretamente referenciado em seu projeto, e obviamente, utilizar as classes e métodos do mesmo, fazendo um acesso dinâmico a estes recursos.

Veja na listagem abaixo um exemplo clássico de como acessar um assembly através de Reflection. O resultado você confere na figura logo a seguir

System.Reflection.Assembly o = 
    System.Reflection.Assembly.Load(
        "mscorlib.dll");
MessageBox.Show(o.GetName().ToString());

Mas qual a vantagem de utilizarmos o Reflection? O exemplo mais prático e útil que eu conheço do uso do Reflection, é a chamada dinâmica de métodos, seja de um assembly externo ou não.

Imagine que durante a execução da sua aplicação você tenha que calcular os Impostos de uma Nota Fiscal. Porém, o calculo do Imposto depende diretamente do Estado de Destino desta Nota. Sendo assim temos uma rotina ou método para cada Estado.

Que tal colocar essas informações na tabela de Estado, e fazer uma chamada dinâmica à estes métodos. Veja na próxima figura como ficaria a nossa tabela de Estados.

Note que a coluna Metodo armazena apenas uma string que irá representar o nome do método a ser chamado. Sendo assim, podemos ter estes métodos onde desejarmos, veja o exemplo da próxima listagem:

private void button1_Click(object sender, EventArgs e)
{
    // Essa informacao pose ser pesquisada no 
    // database
    string NomeMetodo = "Imposto_MG";

    // Você pode enviar quantos parametros quiser
    object[] Parametros = new object[1];
    Parametros[0] = 100.00;

    double Vr_Imposto = 0;
            
    // Procurando metodo pelo Nome, no assembly 
    // atual
    System.Reflection.MethodInfo metodo = 
        this.GetType().GetMethod(NomeMetodo);
    if (metodo != null)
        Vr_Imposto = 
            (double)metodo.Invoke(this, Parametros);

    MessageBox.Show(Vr_Imposto.ToString());
}
        
/// Rotina para calculo do Imposto para SP
public double Imposto_SP(double Vr_Nota)
{            
    return Vr_Nota * 0.12;
}

/// Rotina para calculo do Imposto para RJ
public double Imposto_RJ(double Vr_Nota)
{            
    return Vr_Nota * 0.07;
}

/// Rotina para calculo do Imposto para MG
public double Imposto_MG(double Vr_Nota)
{            
    return Vr_Nota * 0.18;
}

Veja que temos três métodos para o calculo do Imposto, um para cada Estado cadastrado na tabela. Em todos os métodos recebemos como parâmetro o valor da Nota Fiscal, e retornarmos o imposto calculado.

Neste exemplo estamos fazendo a chamada no evento click de um botão qualquer. Veja que o nome do método foi colocado como Imposto_MG, mas esta informação obviamente deve ser recuperada do database, ou da onde você desejar.

Note que estamos criando um objeto para encapsular os parâmetros, e em seguida através do método GetMethod, criamos uma referencia ao método com o nome que está na variável NomeMetodo. Em seguida estamos fazendo a chamada deste método através do método Invoke.

Faça alguns testes e veja que o método chamado será sempre o indicado na string NomeMetodo.

É claro que o Reflection não se resume a isso, temos um namespace inteiro dedicado a ele (System.Reflection). Mas essa é sem dúvida uma ótima forma de fazer chamadas dinâmicas, tornando a lógica da sua aplicação bem mais flexível.