0Pricing
C# Academy · Lección

Type, MethodInfo, activación y atributos personalizados

Obtenga objetos Type, localice MethodInfo, invoque métodos, cree instancias con Activator y defina y lea atributos personalizados.

Type, MethodInfo, activación y atributos personalizados es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 1 de 3. 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 3 lecciones en total.

Descripción general

Objetivo: Utilice reflection de forma segura.

  • Obtenga Type
  • Busque MethodInfo
  • Cree instancias mediante Activator
  • Defina y lea atributos

Obtener Type

Obtenga Type mediante typeof, a partir de una instancia con GetType() o por nombre mediante Type.GetType.

using System;

public class Sample { }

public class Program
{
  public static void Main(string[] args)
  {
    // 1) From a compile-time type
    Type t1 = typeof(Sample);

    // 2) From an instance
    Sample s = new Sample();
    Type t2 = s.GetType();

    // 3) From a full name (needs assembly-qualified name for external types)
    Type t3 = Type.GetType("System.String");

    Console.WriteLine(t1.Name + ", " + t2.FullName + ", " + (t3 == null ? "null" : t3.Name));
  }
}

MethodInfo.Invoke

Use GetMethod para localizar un método y Invoke para llamarlo. Pase la instancia y el array de argumentos.

using System;
using System.Reflection;

public class Greeter
{
  public string Hello(string name) { return "Hello, " + name; }
}

public class Program
{
  public static void Main(string[] args)
  {
    Greeter g = new Greeter();
    Type t = typeof(Greeter);

    MethodInfo mi = t.GetMethod("Hello"); // public instance method
    object result = mi.Invoke(g, new object[] { "Ada" }); // call dynamically

    Console.WriteLine(result); // Hello, Ada
  }
}

Conceptos básicos de Activator

Activator.CreateInstance(Type) construye un objeto mediante el constructor público sin parámetros.

using System;

public class Person
{
  public string Name { get; set; }
  public Person() { Name = "Unknown"; } // parameterless ctor
}

public class Program
{
  public static void Main(string[] args)
  {
    Type tp = typeof(Person);
    object o = Activator.CreateInstance(tp); // uses public parameterless ctor
    Person p = (Person)o;
    p.Name = "Alan";
    Console.WriteLine("Created: " + p.Name);
  }
}

Atributos personalizados

Cree una clase Attribute pequeña y recupérela mediante GetCustomAttributes en el tipo o método.

using System;
using System.Reflection;

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public sealed class LabelAttribute : Attribute
{
  public string Text { get; private set; }
  public LabelAttribute(string text) { Text = text; }
}

[Label("Utility class")]
public class Utils
{
  [Label("Adds two ints")]
  public static int Add(int a, int b) { return a + b; }
}

public class Program
{
  public static void Main(string[] args)
  {
    Type t = typeof(Utils);

    // Read class attribute
    object[] classAttrs = t.GetCustomAttributes(typeof(LabelAttribute), false);
    if (classAttrs.Length > 0)
      Console.WriteLine("Class label: " + ((LabelAttribute)classAttrs[0]).Text);

    // Read method attribute
    MethodInfo mi = t.GetMethod("Add");
    object[] methodAttrs = mi.GetCustomAttributes(typeof(LabelAttribute), false);
    if (methodAttrs.Length > 0)
      Console.WriteLine("Method label: " + ((LabelAttribute)methodAttrs[0]).Text);
  }
}

Consejos y seguridad

Consejos:

  • Compruebe si Type.GetType devuelve null y si faltan miembros.
  • Prefiera typeof cuando sea posible (es más rápido y seguro).
  • Mantenga el uso de la reflexión centralizado y bien documentado.
  • Use BindingFlags para buscar miembros no públicos o estáticos.

Conceptos básicos de activación

Comprobación rápida: ¿Qué API crea una instancia a partir de un Type que tiene un constructor público sin parámetros?

Resumen

Resumen: Obtenga un Type, busque un MethodInfo, cree la instancia con Activator y lea los atributos mediante GetCustomAttributes.

Preguntas frecuentes

¿La lección «Type, MethodInfo, activación y atributos personalizados» es gratis?

Sí — el texto completo de «Type, MethodInfo, activación y atributos personalizados» 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 3 lecciones en total.

¿Qué aprenderé en «Type, MethodInfo, activación y atributos personalizados»?

Obtenga objetos Type, localice MethodInfo, invoque métodos, cree instancias con Activator y defina y lea atributos personalizados. 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 1 de 3.

¿Cuánto tiempo toma la lección «Type, MethodInfo, activación y atributos personalizados»?

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

  1. Type, MethodInfo, activación y atributos personalizados
  2. Información a nivel de código fuente (atributos Caller)
  3. Escenarios de metaprogramación ligera
← Volver a C# Academy