Métadonnées en C#

C# dans les métadonnées est défini comme les informations binaires qui décrivent notre programme et ces informations sont stockées soit dans un fichier exécutable portable Common Language Runtime, soit en mémoire. Si vous compilez le code à partir d'un fichier exécutable portable, les métadonnées sont insérées dans une partie de zone supplémentaire du fichier et tout ce code sera maintenant converti au format MSIL (Microsoft Intermediate Language), puis le code sera déplacé dans une autre partie de partition du fichier. Tous les types de données et membres de données définis et référencés dans l’assembly sont placés dans les métadonnées. Pendant que nous exécutons le code C# au moment de l'exécution, il charge les métadonnées depuis la mémoire. L'objectif principal des métadonnées C# est de connaître les informations sur la classe, les données membres, l'héritage et les types de données, etc. Les métadonnées du fichier sont constituées de structures de données de table et de tas.

Utilisations des métadonnées

Vous trouverez ci-dessous les utilisations des métadonnées :

• Il fournit une description des types de données d'assemblage tels que le nom, la visibilité, la classe de base et les interfaces, etc.
• Il fournit des données membres telles que des méthodes, des champs, des propriétés, des événements et des types imbriqués.
• Il fournit également une description supplémentaire des éléments qui modifient les types et les membres.
• Il a une identité comme le nom, la version, la clé publique, etc.
• C'est la clé d'un modèle de programmation simple et cela éliminera la nécessité de fichiers IDL (Interface Definition Language), de fichiers d'en-tête.

Types de métadonnées

Vous trouverez ci-dessous la figure des types de métadonnées :

Rôles des métadonnées

Vous trouverez ci-dessous les rôles des métadonnées :

Comment fonctionnent les métadonnées en C# ?

Les métadonnées C# fonctionnaient en connaissant les données sur les données.

Syntaxe :

using packageName;//used for insert the packages in C#
public class MyApp
{
public static int Main()
{
//data types
Console.WriteLine("Required Message");
}
//user defined methods for other logics
}

Exemples de métadonnées en C#

Vous trouverez ci-dessous des exemples de métadonnées en C# :

Exemple n°1

Multiplication de 3 nombres

Code : Multiplication.cs

using System; //Used for declaring the package or used for importing existed packege
public class Multiplication//declaring the class
{
public static int Main ()// main method for displaying the output
{
//declaring and defining the varaiables
int x = 50;
int y = 20;
int z=30;
//Printing the output of the multiplication of 2 numbers
Console.WriteLine ("Multiplication of {0},{1} and {2} is {3}",x,y,z,multiplication(x,y,z));
return 0;
}
public static int multiplication(int x, int y, int z)// multiplication() method implemention
{
return (x * y*z);// return multiplication of 3 numbers
}
}

Sortie :

Explication :

• Comme vous pouvez le voir dans la section À propos, vous pouvez voir les données réelles, si nous voulons des métadonnées ou des données binaires, nous pouvons voir le compilateur à l'intérieur du code généré par la machine, qui est toujours crypté, les humains ne peuvent pas le comprendre.

Exemple n°2

Superficie du carré

Code : SquareOfArea.cs

using System; //Used for declaring the package or used for importing existed packege
public class SquareArea//declaring the class
{
public static int Main ()// main method for displaying the output
{
//declaring and defining the varaiables
int x = 50;
//Printing the output of the areaOfSquare
Console.WriteLine ("Area of Square is {0}",areaOfSquare(x));
return 0;
}
public static int areaOfSquare(int x)// multiplication() method implemention
{
return (x*x);// return area Of Square
}
}

Sortie :

Explication :

• Comme vous pouvez le voir dans la section À propos, vous pouvez voir les données réelles, si nous voulons des métadonnées ou des données binaires, nous pouvons voir le compilateur à l'intérieur du code généré par la machine, qui est toujours crypté, les humains ne peuvent pas le comprendre.

Exemple #3

Plusieurs classes avec des données

Code : MultiData.net

using System; //Used for declaring the package or used for importing existed packege
using System.Collections.Generic; //Used for declaring the package or used for importing existed packege
public class Entity {//declaring the class
//setters and getters for set and get the data
public string Name {get;set;}
public string Uses {get;set;}
//toString method to overide predefined String data
public override string ToString() {
string output1=string.Format("My Name is {0}", Name);
string output2=string.Format(" He is: {0}", Uses);
return output1+output2;
}
}
//declaring interface with reference class extention
public interface IMeta<T> where T: class {
//setters and getter for set and get the data
T Inner {get;set;}
stringMetaData {get;set;}
}
//declaring interface with reference class extention
public interface IStorage<T> where T: class {
//method definition for save the data
T Save();
}
//declaring the class by extending Imeta and IStorage interfaces
public class Meta<T> : IMeta<T>, IStorage<T>
where T: class
{
//creating a generic dictionary variable
private static Dictionary<T, Meta<T>> _stash = new Dictionary<T, Meta<T>>();
//constructor for the class
public Meta(T item) {
Inner = item;
}
//setters and getters for set and get the data
public T Inner {get;set;}
public string MetaData {get;set;}
//method implementation for operator
public static implicit operator T(Meta<T> meta) {
if (! _stash.ContainsKey(meta.Inner))
_stash.Add(meta.Inner, meta);
returnmeta.Inner;
}
public static implicit operator Meta<T>(T item) {
try {
return _stash[item];
} catch {
return null;
}
}
//save the data to repository
public T Save() {
return this;
}
}
//declaring the class
public static class MetaHelper {
//method definition for return the data
public static IMeta<T>GetMeta<T>(T item) where T: class {
return (Meta<T>)item;
}
//method definition for store the data
public static IStorage<T>GetStorage<T>(T item) where T: class {
return (Meta<T>)item;
}
}
//declaring the class
public class Program
{
//Entity type for createEntity method definition with 2 arguments
public static Entity CreateEntity(string name, string uses) {
//creating a variable
var result = new Meta<Entity>(new Entity(){ Name = name, Uses = uses });
//adding data to the variable that is metadata
result.MetaData = "Paramesh";
return  result;
}
//test method to test the data
public static void Main()
{
//Passing the values to createEntity method
varent = CreateEntity("Amardeep", "Good Person");
//types casting ent into Meta class
Meta<Entity> meta = (Meta<Entity>)ent;
//creating variables
varimeta = MetaHelper.GetMeta<Entity>(ent);
varistore = MetaHelper.GetStorage<Entity>(ent);
var stored = istore.Save();
//Displaying output
Console.WriteLine("MetaData: {0} {1} {2} {3}", imeta.MetaData, imeta.Inner.Name, stored.Name, stored.Uses);
Console.WriteLine(ent);
if (meta != null) Console.WriteLine(meta.MetaData);
elseConsole.WriteLine("This is not a meta type");
}
}

Sortie :

Explication :

• Comme vous pouvez le voir dans la section À propos, vous pouvez voir les données réelles, si nous voulons des métadonnées ou des données binaires, nous pouvons voir le compilateur à l'intérieur du code généré par la machine, qui est toujours crypté, les humains ne peuvent pas le comprendre.

Conclusion

Les métadonnées en C# sont utilisées pour connaître les données sur les données. Tout cela est crypté au format binaire, ce qui n'est pas compréhensible par l'homme, c'est pourquoi nous convertissons le code binaire en code normal et analysons la logique.

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!