c# - refraccion - reflexion de la luz

¿Por qué se recomienda el uso de la reflexión en.NET?

Question

¿Definitivamente es una buena práctica usarlo?

¿Cuáles son algunas situaciones posibles en un proyecto que necesitan reflexión?

Answer 1

Como se mencionó anteriormente, el rendimiento tendrá éxito.

Otra gran ventaja es que puede cargar ensamblajes dinámicamente, realizar manipulaciones de propiedades aunque no tenga el alcance para ver qué cambiar, etc.

Las razones para usar esto son muchas. Aquí hay una introducción si es necesario.

Answer 2

El valor principal de Reflection es que se puede usar para inspeccionar conjuntos, tipos y miembros. Es una herramienta muy poderosa para determinar el contenido de un ensamblaje u objeto desconocido y se puede usar en una gran variedad de casos.

Los oponentes de Reflection citarán que es lento, lo cual es cierto cuando se compara con la ejecución de código estático; sin embargo, Reflection se usa en todo el framework .NET y, siempre que no se abuse, puede ser una herramienta muy poderosa en el toolkit.

Algunas aplicaciones útiles:

• Determinación de dependencias de un ensamblaje

• Los tipos de ubicación que se ajustan a una interfaz, derivan de una clase base / abstracta y buscan miembros por atributos

• Prueba (maloliente): si dependes de una clase que no puede ser comprobada (es decir, no te permite construir fácilmente una falsificación), puedes usar Reflection para inyectar valores falsos dentro de la clase; no es bonita ni recomendable, pero puede ser una herramienta útil en un enlace.

• Depuración: eliminación de una lista de los ensamblados cargados, sus referencias, métodos actuales, etc.

Answer 3

Hay muchos usos para la reflexión:

1. Iterando a través de propiedades en un objeto.
2. Invocando un método que está definido en tiempo de ejecución.
3. Muchos otros más en la misma vena.

Sin embargo, uno de mis usos favoritos de la reflexión es encontrar propiedades que hayan sido marcadas con atributos.

Por ejemplo, escribí atributos que marcan qué propiedades en mis clases deberían indexarse ​​usando Lucene. En el tiempo de ejecución, puedo ver cualquier clase y averiguar qué campos necesitan para ser indexados simplemente preguntando a la clase por las propiedades "marcadas".

Answer 4

La muy útil clase XmlSerialization se basa en la reflexión. No necesita lidiar con la reflexión usted mismo para usar la serialización, las clases de serialización invocan la reflexión ellos mismos. Pero ayuda a etiquetar su código con Atributos que guían cómo se serializan los objetos. Las clases de serialización usan la reflexión en tiempo de ejecución para leer esos atributos. Al final, el proceso parece casi mágico, requiriendo muy pocas líneas de codificación explícita en una aplicación; es la reflexión lo que hace posible esa conveniencia.

XmlSerialization en sí mismo es asombroso no solo porque es una forma muy conveniente de crear archivos de datos desde una aplicación, sino que también es un medio muy fácil de generar registros legibles por humanos del modelo de datos interno de un programa para fines de depuración.

Answer 5

La reflexión es solo una forma de investigar objetos durante el tiempo de ejecución. No deberías usarlo si no necesitas hacer eso.

Answer 6

La reflexión se usa comúnmente en contenedores IoC. Digamos que desea registrar cada clase concreta que termina con la palabra "Controlador". La reflexión lo convierte en un pedazo de pastel.

También utilicé la reflexión para manipular campos privados cuando las clases de prueba unitaria.

Answer 7

Puede usar el reflejo para implementar un sistema de complementos, por ejemplo. Simplemente busca todas las DLL en una carpeta y, a través de una comprobación de reflexión, implementa una cierta interfaz de complemento. Este es el propósito principal para el que utilicé la reflexión, pero también lo utilicé para implementar una serialización genérica de objetos domésticos, donde el rendimiento no era la mayor preocupación.

Answer 8

Viniendo de C ++ y habiendo necesitado algunas jerarquías simples de clase, ¡puedo decir que la palabra clave es invaluable!

class MenuItem : Item { }

foreach(Item items in parent.ChildItems) {
    if (item is MenuItem) { /* handle differently */ }
}

PD: ¿La reflexión no es un poco cara, por cierto?

Answer 9

Reflection permite que una aplicación recolecte información sobre sí misma y también la manipule sobre sí misma. Se puede usar para buscar todos los tipos en un ensamblaje y / o invocar dinámicamente métodos en un ensamblaje.

System.Reflection: namespace contiene las clases y las interfaces que proporcionan una vista administrada de tipos, métodos y campos cargados, con la capacidad de crear e invocar dinámicamente tipos; este proceso se conoce como Reflection en .NET framework.

System.Type: class es la clase principal para la funcionalidad .NET Reflection y es la forma principal de acceder a los metadatos. La clase System.Type es una clase abstracta y representa un tipo en el Common Type System (CLS).

Representa las declaraciones de tipos: tipos de clase, tipos de interfaz, tipos de matriz, tipos de valores, tipos de enumeración, parámetros de tipo, definiciones de tipos genéricos y tipos genéricos construidos abiertos o cerrados.

P.ej:

using System;
using System.Reflection;

static class ReflectionTest
{
    public static int Height;
    public static int Width;
    public static int Weight;
    public static string Name;

    public static void Write()
    {
    Type type = typeof(ReflectionTest); // Get type pointer
    FieldInfo[] fields = type.GetFields(); // Obtain all fields
    foreach (var field in fields) // Loop through fields
    {
        string name = field.Name; // Get string name
        object temp = field.GetValue(null); // Get value
        if (temp is int) // See if it is an integer.
        {
        int value = (int)temp;
        Console.Write(name);
        Console.Write(" (int) = ");
        Console.WriteLine(value);
        }
        else if (temp is string) // See if it is a string.
        {
        string value = temp as string;
        Console.Write(name);
        Console.Write(" (string) = ");
        Console.WriteLine(value);
        }
    }
    }
}

class Program
{
    static void Main()
    {
    ReflectionTest.Height = 100; // Set value
    ReflectionTest.Width = 50; // Set value
    ReflectionTest.Weight = 300; // Set value
    ReflectionTest.Name = "ShekharShete"; // Set value
    ReflectionTest.Write(); // Invoke reflection methods
    }
}

Output

Height (int) = 100
Width (int) = 50
Weight (int) = 300
Name (string) = ShekharShete