Metadata in C#

C# in metadata is defined as the binary information which is describing our program and this information is stored either in common language runtime portable executable file or in memory. If you compile the code from portable executable file then metadata is inserted in one more area portion of the file and all this code will now be converted into MSIL format (Microsoft Intermediate Language) then code moved into another partition portion of the file. All data types and data members that is defined and referenced in the assembly is put within the metadata. While we are executing the C# code at the runtime, it loads the metadata from the memory. The main purpose of the C# metadata is to know the information about the class, data members, inheritance, and data types etc. of the class. Metadata in the file consists of table and heap data structures.

Uses of Metadata

Given below are the uses of Metadata:

• It provides description about assembly data types like name, visibility, base class and interfaces etc.
• It provides data members like methods, fields, properties, events and nested types.
• It also provides additional description of the elements that modify types and members.
• It have identity like name, version, public key etc.
• It is a key to simple programming model and it will eliminate the necessity for IDL (Interface Definition Language) files, header files.

Types of Metadata

Given below is the figure of types of metadata:

Roles of the Metadata

Given below are the roles of metadata:

How does Metadata works in C#?

C# Metadata worked knowing about the data about the data.

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
}

Examples of Metadata in C#

Given below are the examples of Metadata in C#:

Example #1

Multiplication of 3 Numbers

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

Output:

Explanation:

• As you can see in the about you can see the actual data, if we want metadata or binary data we can see the compiler inside machine generated code, that is always encrypted humans can’t understand it.

Example #2

Area of Square

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

Output:

Explanation:

• As you can see in the about you can see the actual data, if we want metadata or binary data we can see the compiler inside machine generated code, that is always encrypted humans can’t understand it.

Example #3

Multiple Classes with Data

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>> _stash = new Dictionary<t meta>>();
//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");
}
}</entity></entity></entity></entity></entity></t></t></t></t></t></t></t></t></t></t></t></t></t></t></t>

Output:

Explanation:

• As you can see in the about you can see the actual data, if we want metadata or binary data we can see the compiler inside machine generated code, that is always encrypted humans can’t understand it.

Conclusion

Metadata in C# is used for knowing the data about the data. This is all encrypted into binary format, which not human understandable that’s why we are converting binary code into normal code analyze the logic.

The above is the detailed content of Metadata in C#. For more information, please follow other related articles on the PHP Chinese website!