Metadaten in C#

C# in Metadaten ist als binäre Information definiert, die unser Programm beschreibt, und diese Information wird entweder in einer tragbaren ausführbaren Common Language Runtime-Datei oder im Speicher gespeichert. Wenn Sie den Code aus einer portablen ausführbaren Datei kompilieren, werden Metadaten in einen weiteren Bereichsteil der Datei eingefügt und der gesamte Code wird nun in das MSIL-Format (Microsoft Intermediate Language) konvertiert, dann wird der Code in einen anderen Partitionsteil der Datei verschoben. Alle in der Assembly definierten und referenzierten Datentypen und Datenelemente werden in die Metadaten eingefügt. Während wir den C#-Code zur Laufzeit ausführen, lädt er die Metadaten aus dem Speicher. Der Hauptzweck der C#-Metadaten besteht darin, Informationen über die Klasse, Datenmitglieder, Vererbung und Datentypen usw. der Klasse zu erhalten. Metadaten in der Datei bestehen aus Tabellen- und Heap-Datenstrukturen.

Verwendung von Metadaten

Im Folgenden sind die Verwendungsmöglichkeiten von Metadaten aufgeführt:

• Es enthält eine Beschreibung zu Assembly-Datentypen wie Name, Sichtbarkeit, Basisklasse und Schnittstellen usw.
• Es stellt Datenelemente wie Methoden, Felder, Eigenschaften, Ereignisse und verschachtelte Typen bereit.
• Es enthält außerdem eine zusätzliche Beschreibung der Elemente, die Typen und Mitglieder ändern.
• Es hat Identitäten wie Name, Version, öffentlicher Schlüssel usw.
• Es ist ein Schlüssel zu einem einfachen Programmiermodell und macht IDL-Dateien (Interface Definition Language) und Header-Dateien überflüssig.

Arten von Metadaten

Nachstehend finden Sie die Abbildung der Metadatentypen:

Rollen der Metadaten

Im Folgenden sind die Rollen von Metadaten aufgeführt:

Wie funktionieren Metadaten in C#?

C#-Metadaten haben funktioniert, da sie die Daten über die Daten kennen.

Syntax:

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
}

Beispiele für Metadaten in C#

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

Beispiel #1

Multiplikation von 3 Zahlen

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

Ausgabe:

Erklärung:

• Wie Sie in der Beschreibung sehen können, können Sie die tatsächlichen Daten sehen. Wenn wir Metadaten oder Binärdaten benötigen, können wir den Compiler im maschinengenerierten Code sehen, der immer verschlüsselt ist und von Menschen nicht verstanden werden kann.

Beispiel #2

Quadratfläche

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

Ausgabe:

Erklärung:

• Wie Sie in der Beschreibung sehen können, können Sie die tatsächlichen Daten sehen. Wenn wir Metadaten oder Binärdaten benötigen, können wir den Compiler im maschinengenerierten Code sehen, der immer verschlüsselt ist und von Menschen nicht verstanden werden kann.

Beispiel #3

Mehrere Klassen mit Daten

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

Ausgabe:

Erklärung:

• Wie Sie in der Beschreibung sehen können, können Sie die tatsächlichen Daten sehen. Wenn wir Metadaten oder Binärdaten benötigen, können wir den Compiler im maschinengenerierten Code sehen, der immer verschlüsselt ist und von Menschen nicht verstanden werden kann.

Fazit

Metadaten in C# werden verwendet, um die Daten über die Daten zu kennen. Dies alles ist im Binärformat verschlüsselt, was für den Menschen nicht verständlich ist. Deshalb wandeln wir Binärcode in normalen Code um und analysieren die Logik.

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