Réflexion en C#

La réflexion en C# est le processus de collecte d'informations sur ses fonctionnalités et d'opération sur lui-même. Les informations collectées incluent les propriétés, le type, les événements et les méthodes d'un objet ; la réflexion est utile pour trouver tous les types d’assemblages. Dynamiquement, il invoque une méthode d'assemblage que nous pouvons lier dynamiquement ou obtenir le type vers ou depuis un objet existant ; la réflexion est utilisée pour créer une instance du type. Nous pouvons accéder à ses propriétés et à ses champs, le but principal de la réflexion étant utilisé pour lire ses métadonnées pour rechercher les assemblys pendant l'exécution.

Pourquoi avons-nous besoin de Reflection en C# ?

Nous avons besoin de la réflexion en C# pour obtenir les informations de type pendant l'exécution ; il s'agit du processus d'observation du code managé pour lire ses métadonnées afin de rechercher des modules et des assemblys pendant l'exécution. La réflexion se reflète dans le programme en extrayant les métadonnées de ses assemblages, qui sont utilisées pour modifier son comportement.  Le système. L'espace de noms Reflection vous permet d'accéder à la vue gérée des méthodes, des types chargés et des champs pour créer dynamiquement et appeler des types. Nous avons besoin d'une réflexion pour que le processus de candidature suivant soit effectué,

• Pendant le processus d'exécution, la réflexion permet de visualiser les informations d'attribut.
• La réflexion permet une liaison tardive aux propriétés et aux méthodes
• Il examine plusieurs types d'assemblages et leurs types
• Il permet la création de nouveaux types pendant l'exécution et effectue diverses tâches en suivant ces types.

Comment fonctionne Reflection en C# ?

C# Reflection permet à l'application d'obtenir des informations elle-même et de fonctionner sur elle-même. Il recherche efficacement tous les types d'assemblys et invoque dynamiquement les méthodes d'assemblage.

La classe la plus importante utilisée dans la réflexion est le système. La classe de types est une classe abstraite représentant un type appelé CTS (Common Type System). En utilisant cette classe, nous pouvons trouver les types que nous avons utilisés dans les modules d'espace de noms et vérifier que le type donné est un type valeur ou référence. En utilisant les éléments suivants, nous pouvons analyser les tables de métadonnées,

• Méthodes
• Propriétés
• Événements
• Champs

En utilisant la réflexion, la liaison tardive est obtenue ; pendant la compilation, nous pourrions ne pas savoir quel assembly charger pour ces raisons ; nous chargeons l'assembly approprié en demandant aux utilisateurs de saisir le nom et le type de l'assembly lors de l'exécution. En abordant le chargement direct sur les assemblys, nous optons pour System. Réflexion. L'assemblage en obtenant trois types statiques est,

• ChargerDe
• ChargerModule
• ChargerAvecPartialName

Considérant que l'assembly est un fichier exe ou dll, ce fichier est un fichier exécutable portable pour Common Type System, qui a une extension .dll ou .exe. Un fichier exécutable portable est une métadonnée qui contient plusieurs tables comme suit,

• Tableau de définition des méthodes
• Tableau de définition des types
• Tableau de définition des champs

Exemples de réflexion en C#

Vous trouverez ci-dessous les exemples de réflexion en C# :

Exemple n°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);
}
}
}

Dans le code ci-dessus, nous avons chargé le type _type sous forme de chaîne en utilisant la méthode typeof. Ensuite, nous relatons la réflexion sur _type pour trouver les informations sur la classe de chaîne, y compris l'espace de noms, le nom, le nom complet et le type de base.

Sortie :

Exemple n°2

Dans ce programme, nous obtenons l'assembly en définissant la méthode typeof et passons par cette méthode _type. Assemblée. Voyons l'exemple de programme

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

Sortie :

Exemple #3

Dans ce programme, nous montrons les métadonnées en utilisant la réflexion ; il comprend des méthodes, des classes et divers constructeurs paramétrés. Voyons l'exemple ci-dessous,

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

Sortie :

Exemple n°4

La réflexion est le processus d'observation et de modification dynamique de sa structure et de son comportement réels. Dans l'exemple de programme ci-dessous, Reflection permet d'analyser et de modifier les informations de l'application pendant l'exécution.  Voyons l'exemple,

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

Ici, nous pouvons changer la valeur d'une variable pendant l'exécution en connaissant son nom. En utilisant la réflexion, nous pouvons réaliser ce type de méthodes. Voyons le résultat ci-dessous comme suit,

Sortie :

Conclusion

J'espère que vous avez apprécié l'article ; C# Reflection couvre ici les fonctionnalités importantes de .Net ; nous avons appris comment Reflection fonctionne en C#.Net avec plusieurs exemples. J'espère que cet article vous aidera à une bonne compréhension.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!