Mapping--ZT Unified Teaching Network

Mapping

In many cases, we need a way to access the property from the metadata, and C # provides support for the mapping to access the metadata. By initializing the MemberInfo type object, this object in the System.Reflection namespace can be used to discover the properties of the member and access the metadata.

System.reflection.memberinfoinf=typeof (MyMath);

Calls the TypeOf operator on the MyMath type, which returns a variable of type types generated by the inherited MemberInfo.

The next step is to call GetCustomAttributes on the MemberInfo object and pass the type of the desired property as a parameter to the GetCustomAttributes. We'll get an array of objects, and the type of each member of the array is bugfixattribute.

Object[]attributes;
Attributes=attribute.getcustomattributes (inf,typeof (Bugfixattribute));

We can iterate through this array, print an array of Bugfixattribute objects, as shown in the code:



Printing of properties


Publicstaticvoidmain ()
{
Mymathmm=newmymath ();
Console.WriteLine ("Callingdofunc" (7). Result:{0} ",
Mm. DOFUNC1 (7));

Get member information and use it to access custom properties
System.reflection.memberinfoinf=typeof (MyMath);
Object[]attributes;
attributes=
Attribute.GetCustomAttributes (inf,typeof (Bugfixattribute));

Iterate through all the properties
foreach (Objectattributeinattributes)
{
Bugfixattributebfa= (Bugfixattribute) attribute;
Console.WriteLine ("\nbugid:{0}", BFA. BugID);
Console.WriteLine ("Programmer:{0}", BFA. Programmer);
Console.WriteLine ("Date:{0}", BFA. Date);
Console.WriteLine ("Comment:{0}", bfa.comment);
}
}



Type discovery


We can study the content of a composite entity by mapping, and this method is useful if we want to create a tool that needs to display the inner information of the assembly or invoke the path in the assembly dynamically.

By mapping the method, we can know the type of a module, method, domain, attribute, and the signal of each method of that type, the interface supported by the class, and the superclass of the class. We can dynamically load a combination using the Assembly.Load static method in the following form:

Publicstaticassembly.load (AssemblyName)

You can then pass it to the core library.

Assemblya=assembly.load ("Mscorlib.dll");

Once the assembly is loaded, we can return a type Object array by calling GetTypes. The type object is the core of the mapping, which represents the type definitions of classes, interfaces, arrays, values, and enumerations.

Type[]types=a.gettypes ();

Combined recess returns an array of types that we can display using the FOREACH-LOOP structure, and the output will have several pages of documentation, and here's a short paragraph:

Typeissystem.typecode
TypeisSystem.Security.Util.StringExpressionSet
Typeissystem.text.utf7encoding$encoder
Typeissystem.argiterator
TypeisSystem.Runtime.Remoting.JITLookupTable
1205typesfound

We've got an array of types in the core library that can print all of them, and the array will have 1205 entries.

For a type mapping we can also map a type in the composition. To do this, we can use the GetType method to parse a type from the composition: