Enlace tardío usando Reflection en C#

Los dos términos principales que aparecen en el tema anterior son enlace tardío y reflexión. Así que primero definamos estos dos términos. La vinculación de métodos y objetos durante el tiempo de ejecución se denomina vinculación tardía o vinculación dinámica . La reflexión es la capacidad de un ensamblaje para inspeccionar sus metadatos. Los metadatos contienen la información de los datos dentro del ensamblaje. 
La reflexión se usa para implementar el enlace tardío, ya que le permite usar código que no está disponible en tiempo de compilación. Veremos los ejemplos de esto en los siguientes segmentos de código.

Ejemplo 1: en este programa, utilizamos el enlace tardío porque no tenemos el conocimiento de la clase que debe instanciarse en tiempo de compilación. Declare un objeto llamado ejecución de la clase Asamblea y cargue la Asamblea actual utilizando el método GetExecutingAssembly . A continuación, tenemos que encontrar el tipo de clase que se debe instanciar más tarde, es decir , Student . Para hacer esto, use el método GetType en el objeto de la clase Assembly y almacene el tipo en otro objeto llamado studentType . El método GetType espera un argumento de string que es el nombre completo de la clase, LateBinding.Studenten este caso. Dado que el tipo es desconocido en este punto del programa, usamos la clase Tipo para declarar el tipo de estudiante . Ahora creamos una instancia de studentType usando el método CreateInstance que usa el tipo como parámetro. La clase Activator contiene métodos para crear tipos de objetos local o remotamente u obtener referencias a objetos remotos existentes. A continuación, cree un objeto MethodInfo y use el método GetMethod para almacenar la información. Pase el nombre del método como argumento a GetMethod . Para invocar GetDetails, use el objeto MethodInfo para llamar al método Invoke y pase studentObject como parámetro. Y finalmente, muestra los detalles usando un String dety también definir la clase.

// C# program to show the Late
// Binding using Reflection
using System;
using System.Reflection;
 
namespace LateBinding {
 
class Program {
 
    // Main Method
    static void Main(string[] args)
    {
        // Declare Instance of class Assembly
        // Call the GetExecutingAssembly method
        // to load the current assembly
        Assembly executing = Assembly.GetExecutingAssembly();
 
        // To find the type of the Class Student
        Type studentType = executing.GetType("LateBinding.Student");
 
        // Create an Instance of the Student type
        object studentObject = Activator.CreateInstance(studentType);
 
        // Store the info of the method in an object
        // of class MethodInfo
        MethodInfo getMethod = studentType.GetMethod("GetDetails");
 
        // To store the parameters required
        // by Method GetDetails
        String[] param = new String[2];
        param[0] = "1";
        param[1] = "Lisa";
 
        // To display the result of the method
        String det = (String)getMethod.Invoke(studentObject, param);
        Console.WriteLine("Student Details : ");
        Console.WriteLine("Roll Number - Name \n{0}", det);
 
    } // end Main
 
} // end Program
 
 
public class Student {
 
    public String GetDetails(String RollNumber, String Name)
    {
        return RollNumber + " - " + Name;
    }
 
} // end Student
 
}

Student Details : 
Roll Number - Name 
1 - Lisa

Nota: En el código anterior, si no define la clase y compila el código, se compilará correctamente ya que el enlace no se realiza en el momento de la compilación. Pero cuando lo ejecute, obtendrá un error, ya que solo se encontrará en tiempo de ejecución. El mensaje de error será el siguiente;

Excepción no controlada: System.ArgumentNullException: el valor no puede ser nulo. 
Nombre del parámetro: escriba 
en System.Activator.CreateInstance(Type type, Boolean nonPublic) 
en System.Activator.CreateInstance(Type type) 
en LateBinding.Program.Main(String[] args) en m:\Documents\Visual Studio 2012\Projects \LateBinding\LateBinding\Program.cs:línea 19 
 

Ejemplo 2: Otro ejemplo similar es el código que se proporciona a continuación que tiene una clase Shape y estamos vinculando tarde el método shapeName. 

// C# program to show the Late
// Binding using Reflection
using System;
using System.Reflection;
 
namespace Geometry {
 
// class Shape
public class Shape {
 
    // Function that gives the name of the
    // shape based on the number of sides
    // the number of sides is a string that
    // contains the value
    public String shapeName(String sideNumber)
    {
        if (sideNumber == "0" || sideNumber == "1" || sideNumber == "2")
            return "Not Valid";
        else if (sideNumber == "3")
            return "Triangle";
        else if (sideNumber == "4")
            return "Quadrilateral";
        else
            return "Polygon";
    }
 
} // end Shape
 
class Program {
 
    // Main Method
    static void Main(string[] args)
    {
        // Object of Assembly class
        Assembly executable = Assembly.GetExecutingAssembly();
 
        // To find the type of the class
        Type shapeType = executable.GetType("Geometry.Shape");
 
        // To create an instance of Shape class
        // without prior information about it
        object shapeObject = Activator.CreateInstance(shapeType);
 
        // To find the info about the method
        MethodInfo shapeNameMethod = shapeType.GetMethod("shapeName");
 
        // Prepare parameters for the method
        String[] param = new String[1];
        param[0] = "4";
 
        // To invoke the method using Invoke
        String sName = (String)shapeNameMethod.Invoke(shapeObject, param);
 
        // To  display the name of the shape
        Console.WriteLine("Name of the Shape is {0}", sName);
 
    } // end Main
 
} // end Program
 
}

Name of the Shape is Quadrilateral

Nota: La desventaja de Late Binding es que si comete algún error ortográfico en el nombre de un método o clase, el compilador no lo identificará en el momento de la compilación y, por lo tanto, el código se compilará correctamente. En la mayoría de los escenarios prácticos, se utiliza la vinculación anticipada en lugar de la vinculación tardía.