C# Academy · Lektion

Type, MethodInfo, aktivering och egna attribut

Hämta Type-objekt, hitta MethodInfo, anropa metoder, skapa instanser med Activator och definiera/läs egna attribut.

Lektion 1 av 38 steg

Type, MethodInfo, aktivering och egna attribut är en gratis lektion i C# Academy på CoddyKit. Detta är lektion 1 av 3. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för C# Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C# Academy innehåller totalt 3 lektioner.

Översikt

Mål: Använd reflection på ett säkert sätt.

  • Hämta Type
  • Hitta MethodInfo
  • Skapa via Activator
  • Definiera och läs attribut

Hämta Type

Hämta Type från typeof, från en instans med GetType() eller efter namn via 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

Använd GetMethod för att hitta en metod och Invoke för att anropa den. Skicka med instansen och en argumentarray.

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
  }
}

Grunderna i Activator

Activator.CreateInstance(Type) konstruerar ett objekt med hjälp av den offentliga parameterlösa konstruktorn.

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);
  }
}

Anpassade attribut

Skapa en liten Attribute-klass och hämta den via GetCustomAttributes på typen eller metoden.

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);
  }
}

Tips och säkerhet

Tips:

  • Kontrollera om null returneras från Type.GetType och om medlemmar saknas.
  • Föredra typeof när det är möjligt (snabbare och säkrare).
  • Håll användningen av reflection centraliserad och väl dokumenterad.
  • Använd BindingFlags för sökningar efter icke-offentliga eller statiska medlemmar.

Grunderna i aktivering

Snabb kontroll: Vilket API skapar en instans från en Type som har en offentlig parameterlös konstruktor?

Sammanfattning

Sammanfattning: Hämta en Type, hitta MethodInfo, skapa en instans med Activator och läs attribut med hjälp av GetCustomAttributes.

Gratis att börja

Lär dig C# med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
93
Lektioner
346

Vanliga frågor

Är lektionen ”Type, MethodInfo, aktivering och egna attribut” gratis?

Ja – hela texten till ”Type, MethodInfo, aktivering och egna attribut” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i C# Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i C# Academy innehåller totalt 3 lektioner.

Vad lär jag mig i ”Type, MethodInfo, aktivering och egna attribut”?

Hämta Type-objekt, hitta MethodInfo, anropa metoder, skapa instanser med Activator och definiera/läs egna attribut. Ni övar på C# Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig C# Academy?

Du behöver inga förkunskaper. Utbildningen i C# Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 3.

Hur lång tid tar lektionen ”Type, MethodInfo, aktivering och egna attribut”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här C# Academy-lektionen?

Ja. Varje C# Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Type, MethodInfo, aktivering och egna attribut
  2. Information på källkodsnivå (Caller-attribut)
  3. Enkla metaprogrammeringsscenarier
← Tillbaka till C# Academy