Properties and Meta data--ZT

Properties and Meta data


A notable difference between C # and C + + is that it provides support for metadata: data about other entities such as classes, objects, methods, and so on. Attributes can be grouped into two categories: one in the form of a part of the CLR, the other for the properties we create ourselves, and the CLR properties used to support serialization, alignment, and COM synergy. Some properties are for a group, some properties are for classes or interfaces, and they are also called attribute targets.

Attributes can be used for their property targets by placing them in square brackets before the property target.

[Assembly:assemblydelaysign (False)]
[Assembly:assemblykeyfile (". \\keyFile.snk")]

Or separate the properties with commas:

[Assembly:assemblydelaysign (False),
Assembly:assemblykeyfile (". \\keyFile.snk")]



Custom properties


We can create custom attributes at will, and use them when we think it's appropriate. Suppose we need to track bug fixes, we need to build a database that contains bugs, but we need to bind bug reports to special fixes, and you might add comments like the following in your code:

bug323fixedbyjesseliberty1/1/2005.

In this way, the bug can be clearly understood in the source code, but it might be better to keep the relevant data in the database, which is more convenient for our query work. If all bug reports use the same syntax, that's better, but then we need a custom attribute. We may use the following to replace the comments in the code:

[Bugfix (323, "Jesseliberty", "1/1/2005") comment= "Offbyoneerror"]

As with other elements in C #, properties are also classes. Custom attribute classes need to inherit System.Attribute:

PublicclassBugFixAttribute:System.Attribute

We need to let the compiler know what kind of element this attribute can be with, and we can specify the element of that type in the following way:

[AttributeUsage (Attributetargets.classmembers,allowmultiple=true)]

AttributeUsage is an attribute-━━ meta attribute that provides metadata for metadata, or data about metadata. In this case, we need to pass two parameters, the first is the target (in this case, the class member). , and the second is a token that indicates whether a given element can accept more than one attribute. The value of AllowMultiple is set to true, meaning that a class member can have more than one Bugfixattribute property. If you want to combine two property targets, you can use the OR operator to connect them.

[AttributeUsage (attributetargets.class| Attributetargets.interface,allowmultiple=true)]

The above code will make an attribute subordinate to a class or an interface.

The new custom attribute is named Bugfixattribute. The named rule is to add attribute after the property name. After assigning attributes to an element, the compiler allows us to invoke this property using a thin property name. Therefore, the following code is legal:

[Bugfix (123, "Jesseliberty", "01/01/05", comment= "Offbyone")]

The compiler first looks for the attribute named Bugfix, and if it is not found, finds Bugfixattribute.

Each property must have at least one constructor. Properties can accept two types of parameters: Environment parameters and named parameters. In the previous example, the BugID, the programmer's name and date are ambient parameters, and the annotation is a named parameter. Environment parameters are passed to the constructor and must be passed in the order defined in the constructor.

Publicbugfixattribute (Intbugid,stringprogrammer,stringdate)
{
This.bugid=bugid;
This.programmer=programmer;
This.date=date;
}

Namedparametersareimplementedasproperties.



Use of properties


To test the properties, we create a simple class with the name MyMath, add two functions to it, and then give it a bugfix attribute.

[Bugfixattribute (121, "Jesseliberty", "01/03/05")]

[Bugfixattribute, "Jesseliberty", "01/04/05",
Comment= "Fixedoffbyoneerrors")]
Publicclassmymath



The data is stored with the metadata. Here is the complete source code and its output:



Custom properties

Usingsystem;
To create a custom attribute that is assigned to a class member
[AttributeUsage (AttributeTargets.Class,
Allowmultiple=true)]
PublicclassBugFixAttribute:System.Attribute
{
Custom property Builder for positional parameters
Publicbugfixattribute
(Intbugid,
Stringprogrammer,
StringDate)
{
This.bugid=bugid;
This.programmer=programmer;
This.date=date;
}
Publicintbugid
{
Get
{
Returnbugid;
}
}

Properties of named parameters
Publicstringcomment
{
Get
{
Returncomment;
}
Set
{
Comment=value;
}
}

Publicstringdate
{
Get
{
Returndate;
}
}

Publicstringprogrammer
{
Get
{
Returnprogrammer;
}
}

Proprietary member data
Privateintbugid;
Privatestringcomment;
Privatestringdate;
Privatestringprogrammer;
}

Assigning attributes to a class

[Bugfixattribute (121, "Jesseliberty", "01/03/05")]
[Bugfixattribute, "Jesseliberty", "01/04/05",
Comment= "Fixedoffbyoneerrors")]
Publicclassmymath
{

PUBLICDOUBLEDOFUNC1 (DOUBLEPARAM1)
{
RETURNPARAM1+DOFUNC2 (param1);
}

PUBLICDOUBLEDOFUNC2 (DOUBLEPARAM1)
{
RETURNPARAM1/3;
}

}

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



Output:

Callingdofunc (7). result:9.3333333333333339

As we can see, attributes have absolutely no effect on the output, and creating properties does not affect the performance of the code. So far, the reader is only listening to me about the properties of the problem, using ILDASM to browse the metadata, you will find that the property does exist.