Entendendo o Reflection - ASP.NET/C#

Este artigo tem como objetivo explicar como funciona e como usar o Reflection nas aplicações.

por Francke Peixoto

A reflexão é geralmente usada para Visualizar metadados, Associar métodos e propriedades e descobrir tipos.

Com ele você pode examinar os tipos em um assembly e interagir com eles ou instanciá-los, e também podemos criar tipos no momento de execução.

A principal utilidade da reflexão é criar novos tipos no momento da execução e usá-los para realizar tarefas.

No artigo “Entendendo os Atributos” usamos a reflexão para visualizar os metadados.

usamos o typeof no tipo _Default, o que retorna um objeto do tipo type, derivado do MemberInfo.

A classe Type é o coração das classes de reflexão. Ela encapsula a representação do tipo de um objeto. A classe type é o primeiro caminho para acesso aos metadados. Ela deriva do MemberInfo e encapsula informações sobre os membros de uma classe (métodos, propriedades, campos, eventos e etc.)

O GetCustomAttribute no objeto MemberInfo , passando o tipo do atributo que você deseja encontrar, você receberá um array do tipo ComentariosAttribute

Exemplo:

System.Reflection.MemberInfo info = typeof(_Default);

object[] atts = info.GetCustomAttributes(typeof(ComentariosAttribute), false);

Outra coisa interessante que o reflection faz é descobrir tipos.

Você pode usar a reflexão para explorar e examinar o conteúdo de uma assembly. Você pode encontrar os tipos associados com um módulo; os métodos, campos , propriedades e eventos associados a um tipo, bem como as assinaturas de cada um dos métodos do tipo; a interface suportada pelo tipo e a sua classe básica.

Bom iremos carregar um assembly dinamicamente com o método estático Assembly.Load(). A classe Assembly encapsula o próprio assembly, para fins de reflexão. Uma assinatura para o método é o Load é:

Public static Assembly.Load(AssemblyName)

Iremos carregar a bliblioteca Mscorlib.dll, ela possui as classes principais do .NET Framework:

Assembly a = Assembly.Load("Mscorlib");

Uma vez carregado o assembly, você pode chamar o GetTypes() para retornar um array de objetos Type. Ele representa as declarações do tipo (classes, interfaces, arrays, valores e listas):

Type[] types = a.GetTypes();

O Assembly retorna um array de tipos que você pode exibir em um laço foreach, como ilustrado abaixo:

foreach (Type t in types) {

Console.WriteLine("{0}", t);

}

Console.WriteLine("{0}",types.Length);

A saida para este código seria algo assim:

Para encontrar um membro especifico podemos usar o FindMembers.

O FindMembers recebe 4 parâmetros.

MembersType: Um objeto MemberTypes indica o tipo do membro a ser localizado, pode ser All, Contructor, Vustom, Event, Field, Method, Nestedtype, Property e TypeInfo.

BindingFlags: Uma lista que controla a maneira como as busca serão conduzidas pela reflexão. Alguns dos valores BindingFlags são: IgnoreCase, Instance, Public, Static e outros.

MemberFilter: Um delegado que filtra a lista dos membros no array de objetos MemberInfo.

Object : Um valor string usado pelo filtro. Nesse caso, você passa o Get* para encontrar apenas aqueles métodos que comecem por Get.

Aqui vamos encontrar um membro especifico:

Type _type = Type.GetType("System.Reflection.Assembly");

//APENAS MEMBROS QUE SEJAM METODOS COMECANDO POR GET

MemberInfo[] _minfo = _type.FindMembers(MemberTypes.Method,

BindingFlags.NonPublic |

BindingFlags.Public |

BindingFlags.Static |

BindingFlags.Instance |

BindingFlags.DeclaredOnly, Type.FilterName, "Get*");

foreach (MemberInfo _info in _minfo)

{

Console.WriteLine("{0}",_info.Name);

}

Resultado:

Espero ter deixado claro como funciona o Reflection.

Até o próximo artigo!

[]´s

Baixe o código de exemplo.