C# Academy · Lección

Comprender la reflexión en C#

Use la reflexión para inspeccionar y manipular objetos durante la ejecución

Comprender la reflexión en C# es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 5 de 5. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 5 lecciones en total.

Introducción a la reflexión

Comprender la reflexión en C#

¡Bienvenido a la siguiente lección! En esta lección, aprenderá sobre la reflexión en C#, una función muy potente que permite inspeccionar e interactuar con tipos y objetos en tiempo de ejecución. ¡Comencemos!

¿Qué es la reflexión?

La reflexión es la capacidad de un programa para inspeccionar y manipular su propia estructura en tiempo de ejecución. Se utiliza habitualmente para:

Acceder a los metadatos sobre tipos, métodos y propiedades.
Invocar métodos dinámicamente y acceder a campos.
Crear frameworks y herramientas como serializadores y ORM.

Punto clave: La reflexión forma parte del espacio de nombres System.Reflection.

Acceder a la información de tipos

Utilice la clase Type para acceder a los metadatos sobre un tipo. Ejemplo:

Consejo: Utilice GetProperties, GetMethods y GetFields para inspeccionar los miembros de un tipo.

using System;

class SampleClass {
    public int Id { get; set; }
    public string Name { get; set; }
}

class Program {
    static void Main() {
        Type type = typeof(SampleClass);

        Console.WriteLine("Type Name: " + type.Name);
        Console.WriteLine("Properties:");
        foreach (var prop in type.GetProperties()) {
            Console.WriteLine("- " + prop.Name);
        }
    }
}

Crear objetos dinámicamente

Puede utilizar la reflexión para crear instancias de una clase dinámicamente. Ejemplo:

Punto clave: Utilice Activator.CreateInstance para crear objetos en tiempo de ejecución.

using System;

class SampleClass {
    public string Name { get; set; }
}

class Program {
    static void Main() {
        Type type = typeof(SampleClass);
        object instance = Activator.CreateInstance(type);

        var property = type.GetProperty("Name");
        property.SetValue(instance, "Reflection Example");

        Console.WriteLine("Name: " + property.GetValue(instance));
    }
}

Invocar métodos dinámicamente

La reflexión permite llamar a métodos en tiempo de ejecución sin conocerlos durante la compilación. Ejemplo:

Consejo: Utilice GetMethod e Invoke para realizar llamadas dinámicas a métodos.

using System;

class SampleClass {
    public void Greet(string name) {
        Console.WriteLine("Hello, " + name);
    }
}

class Program {
    static void Main() {
        Type type = typeof(SampleClass);
        object instance = Activator.CreateInstance(type);

        var method = type.GetMethod("Greet");
        method.Invoke(instance, new object[] { "World" });
    }
}

Trabajar con atributos

La reflexión se puede utilizar para inspeccionar atributos personalizados aplicados a tipos, métodos o propiedades. Ejemplo:

Punto clave: Utilice GetCustomAttributes para recuperar la información de los atributos.

using System;

[AttributeUsage(AttributeTargets.Class)]
class SampleAttribute : Attribute {
    public string Description { get; }
    public SampleAttribute(string description) {
        Description = description;
    }
}

[Sample("This is a sample class.")]
class SampleClass {}

class Program {
    static void Main() {
        Type type = typeof(SampleClass);
        var attributes = type.GetCustomAttributes(typeof(SampleAttribute), false);

        foreach (SampleAttribute attr in attributes) {
            Console.WriteLine("Description: " + attr.Description);
        }
    }
}

Desafío práctico

Cree un programa que utilice la reflexión para inspeccionar una clase, enumerar sus métodos y propiedades e invocar uno de sus métodos dinámicamente. Ejemplo:

using System;

class SampleClass {
    public int Add(int a, int b) {
        return a + b;
    }
}

class Program {
    static void Main() {
        Type type = typeof(SampleClass);
        Console.WriteLine("Methods:");
        foreach (var method in type.GetMethods()) {
            Console.WriteLine("- " + method.Name);
        }

        object instance = Activator.CreateInstance(type);
        var addMethod = type.GetMethod("Add");
        int result = (int)addMethod.Invoke(instance, new object[] { 5, 3 });

        Console.WriteLine("Result of Add: " + result);
    }
}

Buenas prácticas al utilizar la reflexión

Estas son algunas buenas prácticas:

Utilice la reflexión con moderación, ya que puede afectar al rendimiento.
Almacene en caché los resultados de la reflexión para mejorar la eficiencia en llamadas repetidas.
Prefiera soluciones en tiempo de compilación a la reflexión cuando sea posible.
Utilice la reflexión en escenarios dinámicos, como plugins y frameworks.

Consejo: Combine la reflexión con atributos personalizados para crear aplicaciones flexibles y dinámicas.

¡Excelente trabajo!

¡Enhorabuena! Ha aprendido a utilizar la reflexión para inspeccionar y manipular tipos en tiempo de ejecución en C#. Con esto concluye la categoría «Funciones avanzadas de C#». ¡Sigamos avanzando hacia nuevas aventuras de programación!

Comprender la reflexión en C# — ilustración 10

Preguntas frecuentes

¿La lección «Comprender la reflexión en C#» es gratis?

Sí — el texto completo de «Comprender la reflexión en C#» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 5 lecciones en total.

¿Qué aprenderé en «Comprender la reflexión en C#»?

Use la reflexión para inspeccionar y manipular objetos durante la ejecución Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 5 de 5.

¿Cuánto tiempo toma la lección «Comprender la reflexión en C#»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Genéricos en C#
Async y await: trabajo con código asíncrono
Comprender los subprocesos y las tareas
Exploración de delegados y lambdas
Comprender la reflexión en C#

← Volver a C# Academy