Förstå reflection i C#
Använd reflection för att granska och manipulera objekt under körning
Förstå reflection i C# är en gratis lektion i C# Academy på CoddyKit. Detta är lektion 5 av 5. 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 5 lektioner.
Introduktion till reflection
Förstå reflection i C#
Välkommen till nästa lektion! I den här lektionen lär ni er om reflection i C#, en kraftfull funktion som gör det möjligt att inspektera och interagera med typer och objekt under körning. Nu börjar vi!
Vad är reflection
Vad är reflection?
Reflection är ett programs förmåga att inspektera och ändra sin egen struktur under körning. Det används vanligtvis för att:
- Få åtkomst till metadata om typer, metoder och egenskaper.
- Anropa metoder dynamiskt och få åtkomst till fält.
- Bygga ramverk och verktyg som serialiserare och ORM-system.
Viktig punkt: Reflection ingår i namnrymden System.Reflection.
Åtkomst till typinformation
Använd klassen Type för att få åtkomst till metadata om en typ. Exempel:
Tips: Använd GetProperties, GetMethods och GetFields för att inspektera typens medlemmar.
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);
}
}
}
Skapa objekt dynamiskt
Ni kan använda reflection för att skapa instanser av en klass dynamiskt. Exempel:
Viktig punkt: Använd Activator.CreateInstance för att skapa objekt under körning.
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));
}
}
Anropa metoder dynamiskt
Reflection gör det möjligt att anropa metoder under körning utan att känna till dem vid kompileringen. Exempel:
Tips: Använd GetMethod och Invoke för dynamiska metodanrop.
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" });
}
}
Arbeta med attribut
Reflection kan användas för att inspektera anpassade attribut som tillämpats på typer, metoder eller egenskaper. Exempel:
Viktig punkt: Använd GetCustomAttributes för att hämta attributinformation.
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);
}
}
}
Övningsuppgift
Skapa ett program som använder reflection för att inspektera en klass, lista dess metoder och egenskaper samt anropa en av metoderna dynamiskt. Exempel:
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);
}
}
Bästa praxis för att använda reflection
Här följer några rekommenderade arbetssätt:
- Använd reflection sparsamt, eftersom det kan påverka prestandan.
- Cachelagra reflectionresultat för att effektivisera upprepade anrop.
- Föredra lösningar vid kompilering framför reflection när det är möjligt.
- Använd reflection i dynamiska scenarier, till exempel för plugin-program och ramverk.
Tips: Kombinera reflection med anpassade attribut för flexibla och dynamiska program.
Bra jobbat!
Grattis! Ni har lärt er att använda reflection för att inspektera och ändra typer under körning i C#. Därmed avslutas kategorin "Avancerade C#-funktioner". Nu går vi vidare till fler kodningsäventyr!
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 ”Förstå reflection i C#” gratis?
Ja – hela texten till ”Förstå reflection i C#” 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 5 lektioner.
Vad lär jag mig i ”Förstå reflection i C#”?
Använd reflection för att granska och manipulera objekt under körning 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 5 av 5.
Hur lång tid tar lektionen ”Förstå reflection i C#”?
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
- Generiska typer i C#
- Async och await: arbeta med asynkron kod
- Förstå trådar och aktiviteter
- Utforska delegater och lambdauttryck
- Förstå reflection i C#