Reflexion in C#

Reflexion ist in C# der Prozess, Informationen über seine Funktionen zu sammeln und an sich selbst zu arbeiten. Zu den gesammelten Informationen gehören die Eigenschaften, der Typ, die Ereignisse und die Methoden eines Objekts. Reflexion ist beim Auffinden aller Arten von Baugruppen hilfreich. Es ruft dynamisch eine Assemblermethode auf, mit der wir den Typ dynamisch an ein vorhandenes Objekt binden oder diesen abrufen können. Reflexion wird verwendet, um eine Instanz des Typs zu erstellen. Wir können auf seine Eigenschaften und Felder zugreifen. Der Hauptzweck der Reflexion besteht darin, seine Metadaten zum Durchsuchen der Baugruppen während der Laufzeit zu lesen.

Warum brauchen wir Reflection in C#?

Wir benötigen die Reflektion in C#, um die Typinformationen zur Laufzeit zu erhalten; Dabei handelt es sich um den Prozess, bei dem verwalteter Code beobachtet wird, um seine Metadaten zu lesen und Module und Assemblys zur Laufzeit zu finden. Reflection spiegelt sich im Programm wider, indem es Metadaten aus seinen Assemblys extrahiert, die zur Änderung seines Verhaltens verwendet werden.  Das System. Mit dem Reflection-Namespace können Sie auf die verwaltete Ansicht von Methoden, geladenen Typen und Feldern zugreifen, um Typen dynamisch zu erstellen und aufzurufen. Wir benötigen die Reflexion für den folgenden Bewerbungsprozess, der dort durchgeführt werden muss,

• Während des Laufzeitprozesses ermöglicht die Reflektion einen Blick auf Attributinformationen.
• Reflexion ermöglicht eine späte Bindung an Eigenschaften und Methoden
• Es untersucht verschiedene Arten von Baugruppen und ihre Typen
• Es ermöglicht die Erstellung neuer Typen während der Laufzeit und führt verschiedene Aufgaben aus, indem es diesen Typen folgt.

Wie funktioniert Reflection in C#?

C# Reflection ermöglicht es der Anwendung, selbst Informationen abzurufen, und arbeitet auch selbst. Es durchsucht effektiv alle Arten von Assemblys und ruft Assembly-Methoden dynamisch auf.

Die wichtigste Klasse, die bei der Reflexion verwendet wird, ist System. Die Typklasse ist eine abstrakte Klasse, die einen Typ namens CTS (Common Type System) darstellt. Mit dieser Klasse können wir die Typen finden, die wir in Namespace-Modulen verwendet haben, und überprüfen, ob der angegebene Typ ein Wert oder Referenztyp ist. Mithilfe der folgenden Elemente können wir die Metadatentabellen analysieren

• Methoden
• Eigenschaften
• Veranstaltungen
• Felder

Mithilfe der Reflexion wird Late Binding erreicht; Während der Kompilierungszeit wissen wir aus diesen Gründen möglicherweise nicht, welche Assembly geladen werden soll. Wir laden die entsprechende Assembly, indem wir die Benutzer bei der Ausführung zur Laufzeit auffordern, den Namen und Typ der Assembly einzugeben. Wenn wir uns dem direkten Laden von Baugruppen nähern, entscheiden wir uns für System. Spiegelung. Die Montage durch Abrufen von drei statischen Typen ist:

• LoadFrom
• LoadModule
• LoadWithPartialName

Wenn man bedenkt, dass es sich bei der Assembly um eine EXE- oder DLL-Datei handelt, handelt es sich bei dieser Datei um portable ausführbare Dateien für Common Type System, die die Erweiterung .dll oder .exe haben. Bei einer portablen ausführbaren Datei handelt es sich um Metadaten, die mehrere Tabellen wie folgt enthalten:

• Methodendefinitionstabelle
• Typdefinitionstabelle
• Felddefinitionstabelle

Beispiele für Reflexion in C#

Im Folgenden finden Sie Beispiele für Reflection in C#:

Beispiel #1

using System;
using System.Reflection;
namespace Reflection_Sample {
class Program_1 {
// Main Method
static void Main(string[] args)
{
// to initialize _type as typeof string
Type _type = typeof(string);
// by using the Reflection to find and in any sort of data related to _type
Console.WriteLine("Name : {0}", _type.Name);
Console.WriteLine("Full Name : {0}", _type.FullName);
Console.WriteLine("Namespace : {0}", _type.Namespace);
Console.WriteLine("Base Type : {0}", _type.BaseType);
}
}
}

Im obigen Code haben wir den Typ _type mit der Methode typeof als String geladen. Dann beziehen wir die Reflexion auf _type, um Informationen zur String-Klasse zu erhalten, einschließlich Namespace, Name, vollständiger Name und Basistyp.

Ausgabe:

Beispiel #2

In diesem Programm erhalten wir die Assembly, indem wir den Methodentyp definieren und auf diese Weise _type erreichen. Montage. Sehen wir uns das Beispielprogramm an

using System;
using System.Reflection;
public class ReflectionExample
{
public static void Main()
{
Type _type = typeof(System.String);
Console.WriteLine(_type.Assembly);
}
}

Ausgabe:

Beispiel #3

In diesem Programm zeigen wir die Metadaten mithilfe der Reflexion an; Es umfasst Methoden, Klassen und verschiedene parametrisierte Konstruktoren. Sehen wir uns das folgende Beispiel an:

using System;
using System.Reflection;
namespace Sample_ReflectionMetadata
{
// to define a class StudentDetails
class StudentDetails
{
// defining the Properties
public int _RollNo
{
get;
set;
}
public string _Name
{
get;
set;
}
// Constructor with no arguments
public StudentDetails()
{
_RollNo = 0;
_Name = string.Empty;
}
// this is a Parameterised Constructor with 2 parameters
public StudentDetails(int _Srollno, string _Sname)
{
_RollNo = _Srollno;
_Name = _Sname;
}
// to invoke method to Display Student Details
public void StudentDisplayData()
{
Console.WriteLine("Roll Number : {0}", _RollNo);
Console.WriteLine("Name : {0}", _Name);
}
}
class ReflectionClass
{
// Main Method
static void Main(string[] args)
{
// to declare Assembly and loading the current assembly
Assembly _executing = Assembly.GetExecutingAssembly();
Type[] _types = _executing.GetTypes();
foreach(var item in _types)
{
Console.WriteLine("Class : {0}", item.Name);
// storing the methods  in array
MethodInfo[] methods = item.GetMethods();
foreach(var method in methods)
{
// for displaying each method
Console.WriteLine("--> Method : {0}", method.Name);
// to store the parameters in array
ParameterInfo[] parameters = method.GetParameters();
foreach(var arg in parameters)
{
Console.WriteLine(" Parameter : {0} Type : {1}",
arg.Name, arg.ParameterType);
}
}
}
}
}
}

Ausgabe:

Beispiel #4

Reflexion ist der Prozess der dynamischen Beobachtung und Veränderung der tatsächlichen Struktur und des Verhaltens. Im folgenden Beispielprogramm sorgt Reflection dafür, dass wir die Informationen in der Anwendung zur Laufzeit analysieren und ändern können.  Sehen wir uns das Beispiel an,

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
namespace ReflectionSample
{
class Program
{
private static int value_1= 15, value_2 = 25, value_3 = 30;
static void Main(string[] args)
{
Console.WriteLine("The Values are = " + (value_1 + value_2 + value_3));
Console.WriteLine("Input the Name of variable to be altered:");
string _varName = Console.ReadLine();
Type _type = typeof(Program);
FieldInfo _fieldInfo = _type.GetField(_varName, BindingFlags.NonPublic | BindingFlags.Static);
if(_fieldInfo != null)
{
Console.WriteLine("The Latest Value of " + _fieldInfo.Name + " is " + _fieldInfo.GetValue(null) + ". Input NeW Value:");
string newValue = Console.ReadLine();
int newInt;
if(int.TryParse(newValue, out newInt))
{
_fieldInfo.SetValue(null, newInt);
Console.WriteLine(" Final Values are = " + (value_1 + value_2 + value_3));
}
Console.ReadKey();
}
}
}
}

Hier können wir den Wert einer Variablen zur Laufzeit ändern, indem wir ihren Namen kennen. Durch den Einsatz von Reflexion können wir diese Art von Methoden erreichen. Sehen wir uns die folgende Ausgabe an:

Ausgabe:

Fazit

Ich hoffe, Ihnen hat der Artikel gefallen; C# Reflection deckt hier die wichtigen Funktionalitäten in .Net ab; Wir haben anhand mehrerer Beispiele gelernt, wie Reflection in C#.Net funktioniert. Ich hoffe, dieser Artikel hilft Ihnen beim besseren Verständnis.

Das obige ist der detaillierte Inhalt vonReflexion in C#. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!