Desenvolvimento - ASP. NET
Entendendo o Reflection - ASP.NET/C#
Este artigo tem como objetivo explicar como funciona e como usar o Reflection nas aplicações.
por Francke PeixotoA 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