Latest web development tutorials

C # reflexión (Reflexión)

medios de reflexión pueden acceder al programa, su capacidad para detectar y modificar su propio estado o comportamiento.

Asamblea contiene el módulo, que contiene tipos, que a su vez contiene miembros. Reflexión ofrece un paquete de objetos ensamblados, módulos y tipos.

Puede utilizar la reflexión para crear dinámicamente una instancia del tipo, el tipo está ligado a un objeto existente, o de obtener el tipo de un objeto existente. A continuación, puede llamar al tipo de enfoque o acceder a sus campos y propiedades.

Pros y contras

ventajas:

  • 1, lo que refleja la mejora de la flexibilidad del proceso y la escalabilidad.
  • 2, reducir el acoplamiento, aumentar la capacidad de adaptación.
  • 3, lo que permite que el programa para crear y controlar cualquier tipo de objeto, sin clase objetivo no modificable antes.

desventajas:

  • 1, los problemas de rendimiento: el uso es esencialmente un reflejo explicar el funcionamiento, cuando los campos y métodos para acceder a mucho más lento que el código directa. Por lo tanto la reflexión sobre la flexibilidad de la aplicación principal y escalabilidad marco exigente, no se recomienda el procedimiento general.
  • 2, el uso de reflexiones difusas dentro de la lógica del programa; programadores quieren ver la lógica en el código fuente, pero la reflexión eludir la tecnología de código fuente, lo que traerá problemas de mantenimiento, y el código de la reflexión más compleja que el código correspondiente directamente .

Reflex usos (reflexión)

Refleja (reflexión) para los siguientes fines:

  • Se le permite ver las propiedades en tiempo de ejecución de la información (atributo).
  • Permite revisar la recopilación de varios tipos, así como ejemplos de estos tipos.
  • Se permite el enlace en tiempo de métodos y propiedades (propiedad).
  • Permite la creación de un nuevo tipo en tiempo de ejecución, y luego el uso de estos tipos realizar algunas tareas.

Ver metadatos

Ya hemos comentado en el apartado anterior, el uso de la reflexión (Reflexión) se pueden ver las propiedades (atributos) de la información.

Objeto de claseSystem.Reflection MemberInfonecesita ser inicializado, para descubrir las propiedades asociadas con la clase (atributo). Para ello, se puede definir una clase de objeto de destino, de la siguiente manera: 

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

El programa siguiente muestra este punto: 

using System;

[AttributeUsage (AttributeTargets.All)]
HelpAttribute clase pública: System.Attribute
{
   Url cadena de sólo lectura pública;

   public string // Tema Tema es un nombre (nombre) parámetros {
      obtener
      {
         tema retorno;
      }
      conjunto
      {

         topic = valor;
      }
   }

   HelpAttribute pública (string url) // url es un (posicional) los parámetros de posicionamiento {
      this.Url = url;
   }

   Tema cadena privada;
}
[HelpAttribute ( "Información sobre la clase MiClase")]
clase MiClase
{
}

AttributeAppl de espacio de nombres
{
   Programa de clases
   {
      static void main (String [] args)
      {
         System.Reflection.MemberInfo info = typeof (MiClase);
         Object [] = atributos info.GetCustomAttributes (true);
         for (int i = 0; i <attributes.Length; i ++)
         {
            System.Console.WriteLine (atributos [i]);
         }
         Console.ReadKey ();

      }
   }
}

Cuando el código se compila y ejecuta, mostrará las propiedades personalizadas unidos a una claseMyClassen: 

HelpAttribute

Ejemplos

En este ejemplo, vamos a utilizardebuginfopropiedad creada en el capítulo anterior, y utiliza la reflexión (Reflexión) para leer los metadatos claseRectangle.

using System;
using System.Reflection;
espacio de nombres BugFixApplication
{
   // Solución de error una propiedad personalizada se asigna a la clase y sus miembros [AttributeUsage (AttributeTargets.Class |
   AttributeTargets.Constructor |
   AttributeTargets.Field |
   AttributeTargets.Method |
   AttributeTargets.Property,
   AllowMultiple = true)]

   Debuginfo clase pública: System.Attribute
   {
      Bugno int privado;
      desarrollador cadena privada;
      lastReview cadena privada;
      mensaje de cadena pública;

      debuginfo pública (int bg, dev cadena, cadena d)
      {
         this.bugNo = BG;
         this.developer = dev;
         this.lastReview = d;
      }

      public int BUGNO
      {
         obtener
         {
            volver BUGNO;
         }
      }
      public String desarrollador
      {
         obtener
         {
            desarrollador de retorno;
         }
      }
      cadena pública LastReview
      {
         obtener
         {
            volver lastReview;
         }
      }
      public String Mensaje
      {
         obtener
         {
            mensaje de retorno;
         }
         conjunto
         {
            message = valor;
         }
      }
   }
   [Debuginfo (45, "Zara Ali", "08/12/2012",
	Message = "El retorno de coincidencia de tipos")]
   [Debuginfo (49, "Nuha Ali", "10/10/2012",
	Mensaje = "variables no utilizada")]
   clase Rectangle
   {
      // Variables de miembro protegido de doble longitud;
      protegida de doble ancho;
      Rectángulo pública (doble L, doble w)
      {
         longitud = l;
         width = w;
      }
      [Debuginfo (55, "Zara Ali", "19/10/2012",
	   Message = "El retorno de coincidencia de tipos")]
      GetArea doble pública ()
      {
         volver longitud * anchura;
      }
      [Debuginfo (56, "Zara Ali", "19/10/2012")]
      Pantalla public void ()
      {
         Console.WriteLine ( "Longitud: {0}", longitud);
         Console.WriteLine ( "Ancho: {0}", ancho);
         Console.WriteLine ( "Área: {0}", getArea ());
      }
   } // Fin de la clase Rectangle  
   
   clase ExecuteRectangle
   {
      static void main (String [] args)
      {
         Rectángulo R = new Rectangle (4.5, 7.5);
         r.Display ();
         Tipo Tipo = typeof (Rectángulo);
         // Traverse la clase Rectangle atributos foreach (atributos de objetos en type.GetCustomAttributes (falso))
         {
            Debuginfo dbi = (debuginfo) atribuye;
            Si (null! = DBI)
            {
               Console.WriteLine ( "Bug no: {0}", dbi.BugNo);
               Console.WriteLine ( "Promotor: {0}", dbi.Developer);
               Console.WriteLine ( "la última revisión: {0}",
					dbi.LastReview);
               Console.WriteLine ( "Observaciones: {0}", dbi.Message);
            }
         }
         
         // Método Iterar atributos foreach (MethodInfo m de type.GetMethods ())
         {
            foreach (Atributo una en m.GetCustomAttributes (verdadero))
            {
               Debuginfo dbi = (debuginfo) a;
               Si (null! = DBI)
               {
                  Console.WriteLine ( "Bug no: {0}, para Método: {1}",
						dbi.BugNo, m.Name);
                  Console.WriteLine ( "Promotor: {0}", dbi.Developer);
                  Console.WriteLine ( "la última revisión: {0}",
						dbi.LastReview);
                  Console.WriteLine ( "Observaciones: {0}", dbi.Message);
               }
            }
         }
         Console.ReadLine ();
      }
   }
}

Cuando el código se compila y ejecuta, produce los siguientes resultados: 

Longitud: 4.5
Anchura: 7,5
Área: 33.75
Bug No: 49
Desarrollador: Nuha Ali
La última revisión: 10/10/2012
Observaciones: la variable no utilizada
Bug No: 45
Desarrollador: Zara Ali
La última revisión: 08/12/2012
Observaciones: Tipo de retorno desajuste
Bug No: 55, para el Método: getArea
Desarrollador: Zara Ali
La última revisión: 19/10/2012
Observaciones: Tipo de retorno desajuste
Bug No: 56, para el Método: Visualización
Desarrollador: Zara Ali
La última revisión: 19/10/2012
observaciones: