Desenvolvimento - C#

.Net Framework Inside : Introdução a Reflection

Veremos neste artigo uma introdução ao conceito de Reflection (Reflexão).

por Guilherme Bacellar Moralez


Vamos falar um pouco sobre Reflection,  mais especificamente neste artigo sobre introdução e conceitos básicos.

O que é e para que serve?

Reflection é a forma como o .NET permite acessar características (construtores, propriedades, métodos, atributos, etc) em Runtime.

O uso de Reflexão (Reflection) é extremamente útil quando falamos de mecanismos de plug-ins, driver e todo outro mecanismo que exija Late Bind (Instância Tardia).

O que é Early Bind?

Vamos falar um pouco de Early Bind antes de começar a falar de Late Bind.

Basicamente, Early Bind é o que fazemos no dia a dia:

C#

System.Security.Cryptography.SHA512 crip = System.Security.Cryptography.SHA512Managed.Create();

VB.Net

Dim crip As System.Security.Cryptography.SHA512 = System.Security.Cryptography.SHA512Managed.Create()

O que observamos neste exemplo é que sabemos antecipadamente o que vamos fazer, ou seja sabemos Early (cedo).

Contudo, existem situações em que não sabemos. Em nosso caso, imagine que vamos precisar usar criptografia, mas, só vamos saber qual algoritmo usado durante o uso do sistema, então, como fazer?

O que é Late Bind?

Em suma, é a criação de instância de objetos que não temos com antecedência o tipo ou a referência do mesmo.

C#

string tipoCriptografia = "System.Security.Cryptography.SHA512Managed";

System.Security.Cryptography.HashAlgorithm crip = (HashAlgorithm) Activator.CreateInstance(Type.GetType(tipoCriptografia));

VB.Net

Dim tipoCriptografia As String = "System.Security.Cryptography.SHA512Managed"

Dim crip As System.Security.Cryptography.HashAlgorithm = CType(Activator.CreateInstance(Type.GetType(tipoCriptografia)), HashAlgorithm)

Os dois exemplos fazem exatamente a mesma coisa, ou seja, criam uma instância da classe “SHA512Managed” para criptografia de Hash, mas, no Late Bind só sabemos o tipo da classe depois.

Não se preocupe em entender esse exemplo agora, eu garanto que ao chegar ao final dos artigos sobre reflexão você vai voltar aqui e entender tudo.

Tipos, O que são Tipos e há Tipos em todos os lugares...

Primeiramente deixem-me apresentá-los a uma entidade do .Net conhecida como “tipo” (Type), eles são as estruturas fundamentais de tudo.

Se você alguma vez já criou uma classe então você já utilizou um “tipo”.

C#

namespace ReflectionCSharp

{

    public class Calculo

    {

    }

}

VB.NET

Namespace ReflectionVBNet

    Public Class Calculo

    End Class

End Namespace

No código acima criamos uma classe com o nome “Calculo”, então o “tipo” dela seria “Calculo” certo?

ERRADO!

Um “tipo” é a soma do Namespace mais a Classe.

Em algumas situações temos de especificar além do Namespace e do nome da Classe, o assembly em que ela está contido, a versão, o idioma e a chave pública da assinatura do assembly (caso exista).

Não vamos usar tipos completos neste artigo, mas como exemplo:

System.Configuration.ApplicationSettingsGroup, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089

A estrutura de declaração de um tipo é:

(Namespace).(Classe), (Assembly), (Versão), (Cultura), (Chave Pública da Assinatura do Assembly)

Lembram do Namespace que usamos em nosso exemplo acima?

Em sua forma completa ele ficaria (Isso com o .Net 2.0):

System.Security.Cryptography.SHA512Managed, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089

Então, vamos gravar a seguinte frase: “Sem Tipos, sem Reflexão”.

Com os Tipos, vamos ao que podemos fazer

Bom, sabendo o que é um “Tipo” você deve se perguntar o que podemos fazer com eles?

A resposta mais simples é: Tudo, menos fazer manteiga.

Vamos pensar assim: O que tem dentro de um “tipo”?

Se pensarmos que um “tipo” é uma espécie de “ponteiro” para uma “classe” então podemos deduzir que temos:

    · Elementos públicos (com o modificador Public) podem ser acessados por todos que utilizam o elemento, em outras palavras, não há limitação de visibilidade.

      · Elementos privados (com o modificador Private) podem ser acessados única e exclusivamente dentro do próprio elemento aonde foi declarado (se for uma propriedade de uma classe, então, ele pode ser acessado apenas de dentro desta classe)

        · Elementos internos (com o modificador Internal) podem ser acessados apenas de dentro do seu próprio assembly.

          · Elementos protegidos (com o modificador Protected) podem ser acessados de dentro do próprio elemento de declaração e também podem ser acessados de dentro de classe que acabe herdando o elemento em que este foi declarado (uma classe filha e uma classe pai).

          Vejamos agora um modificador de acessibilidade dos elementos:

            · Elementos estáticos (Static) são acessados sem que a instância do elemento em que foram declarados precise ser criada pelo programador. São muito comuns em métodos.

            É importante termos em mente esses modificadores, pois, na hora de utilizarmos a reflexão eles serão de grande importância.

            Até o próximo artigo sobre Reflection.
Guilherme Bacellar Moralez

Guilherme Bacellar Moralez - Bacharel em Ciências da Computação, Desenvolvedor .NET há 4 anos, MCAD, Autor de Livros e Artigos, Arquiteto de Software do Projeto D.NET (Framework de Desenvolvimento .NET).
Blog: http://dotnetmax.bacellar.org/