Reflections
  Java e C#
  Abril 2012
Agenda


 Introdução
 Metadata
 Usando Java Annotations
 Acessando C# Assemblies
 Proxies
 InvocationHandler
 DynamicProxy
Reflections

   O que é Reflection ?

               É o processo na qual um programa de computador pode observar e modificar sua própria
                estrutura e comportamento em tempo de execução. [1]



   Principais usos:

               Introspecção de tipo;



               Visualização de metadata;



               Invocação dinâmica;



1- http://en.wikipedia.org/wiki/Reflection_(computer_programming)
Reflections


 É usado em:


   □   Gerenciadores de plug-ins;

   □   Geração de arquivos: TXT, XML, SQL;

   □   Validação de atributos;

   □   Frameworks de Injeção de Dependências;

   □   Bibliotecas de aspectos;

   □   Ferramentas de teste.
Reflections

 Introspecção de tipo:


            Capacidade de determinar o tipo de objeto em tempo de execução:




       Java:                                                        C#:




1- http://en.wikipedia.org/wiki/Reflection_(computer_programming)
Metadata


 Metadata
   □   Meta é uma abstração de um outro conceito.

   □   Metadata são informações de informações, ou seja, em Reflection,
       dados sobre tipos:

         Classes;

         Tipos parametrizados de classes;

         Atributos;

         Métodos e seus parâmetros.
Visualização de Metadata

    Java Packages
Visualização de Metadata - Java Packages


 package java.lang.reflect:
   □   Metadatas:

         para uma classe: java.lang.Class

         para um método: java.lang.reflect.Method

         para um construtor: java.lang.reflect.Constructor

         para um atributo: java.lang.reflect.Field
Visualização de Metadata - Java Packages


 package java.lang.reflect:
      class Class {
               Constructor[] getConstructors();
               Field getDeclaredField(String name);
               Field[] getDeclaredFields();
               Method[] getDeclaredMethods();
               ...
      }

      class Field {
               Class getType();
               ...
      }

      class Method {
               Class[] getParameterTypes();
               Class getReturnType();
               Object invoke(Object obj, Object... args);
               ...
      }
Visualização de Metadata

    C# Namespaces
Visualização de Metadata - C# Namespaces


 namespace System.Reflection:
   □   Metadatas:

         para uma classe: System.Type

         para uma propriedade: System.Reflection.PropertyInfo

         para um método: System.Reflection.MethodInfo

         para um construtor: System.Reflection.ConstructorInfo

         para um atributo: System.Reflection.FieldInfo
Visualização de Metadata - C# Namespaces

 namespace System.Reflection:

class Type {
         ConstructorInfo[] GetConstructors();
         PropertyInfo GetProperty(name);
         FieldInfo[] GetFields(name);
         MethodInfo GetMethod(name);
         MemberInfo[] GetMember(name);
         MemberInfo[] GetMember(name, MemberTypes, BindingFlags);
         ...
}

class MemberInfo {                              MemberTypes.Constructor
         MemberType MemberType;                 MemberTypes.Field
         ...                                    MemberTypes.Method
}
                                                BindingFlags.Public
class MethodInfo {                              BindingFlags.NonPublic
         Class[] getParameterTypes();           BindingFlags.Static
         Class getReturnType();
         ...
}
Invocação dinâmica

    Exemplos
Invocação Dinâmica - Exemplo em Java
 Usando as classes de metadata:
Invocação Dinâmica - Exemplo em C#
 Usando as classes de metadata:
Exemplos Práticos

Java Annotations
Usando Java Annotations
 Uma classe de teste:
Usando Java Annotations

 Mostrando os métodos de uma classe de teste:
Usando Java Annotations
 Uma classe de teste com rastreabilidade com os casos de uso:
Usando Java Annotations
 Obtendo informações da Annotation atlantico.Requisito:
Exemplos Práticos

 C# Assemblies
Acessando um Assembly C#
 Criando uma carregador de plug-ins:
Acessando um Assembly C#
 Implementando a interface:
Acessando um Assembly C#
 Carregando o plug-in dentro do Assembly:
Acessando um Assembly C#
 Carregando o plug-in dentro do Assembly:
Proxies
Proxy Design Pattern
 Proxy Diagram:
InvocationHandler - Java
 Modelo InvocationHandler:
Exemplo usando Java
Exemplo InvocationHandler
 DocumentService:
Exemplo InvocationHandler
 Criando um Proxy:
Exemplo InvocationHandler
 Implementando a interface InvocationHandler:
Exemplo usando C#
C# Reflect Emit
 C#: System.Reflect.Emit
   □   Biblioteca para criar tipos em runtime.
Castle DynamicProxy

 DynamicProxy:
   □   Biblioteca pra criar Proxies dinamicamente usando Reflection Emit.
Exemplo DynamicProxy
 DocumentService:
Exemplo DynamicProxy
 Criando um Proxy:
Exemplo DynamicProxy
 Implementando IInterceptor:
Libraries

 Bibliotecas que auxiliam o uso de reflection:
 □   Java

       CGLIB (http://cglib.sourceforge.net/)

       Javassist (http://www.csg.ci.i.u-tokyo.ac.jp/~chiba/javassist/)

       ASM (http://asm.ow2.org/)



 □   C#

       Castle DynamicProxy
        (http://www.castleproject.org/dynamicproxy/index.html)

       PostSharp (http://www.sharpcrafters.com/postsharp/documentation)

       C# Emit (http://msdn.microsoft.com/en-us/library/exczf7b9.aspx)
Obrigado
        Thanks
                 Grazie
                          Dank

                                  감사

                                    Gracias


                                 Rafael Uchôa

Reflections