C# 4 and .NET 4

334 ❘ ChaPTer 14 reflectiOn
CusTom aTTribuTes
From this book, you have seen how you can define attributes on various items within your program. These
attributes have been defined by Microsoft as part of the .NET Framework class library, and many of them
receive special support from the C# compiler. This means that for those particular attributes, the compiler
could customize the compilation process in specific ways; for example, laying out a struct in memory
according to the details in the StructLayout attributes.
The .NET Framework also allows you to define your own attributes. Clearly, these attributes will not have
any effect on the compilation process, because the compiler has no intrinsic awareness of them. However,
these attributes will be emitted as metadata in the compiled assembly when they are applied to program
elements.
By itself, this metadata might be useful for documentation purposes, but what makes attributes really
powerful is that by using reflection, your code can read this metadata and use it to make decisions at
runtime. This means that the custom attributes that you define can directly affect how your code runs.
For example, custom attributes can be used to enable declarative code access security checks for custom
permission classes, to associate information with program elements that can then be used by testing tools,
or when developing extensible frameworks that allow the loading of plug-ins or modules.
Writing Custom attributes
To understand how to write your own custom attributes, it is useful to know what the compiler does when it
encounters an element in your code that has a custom attribute applied to it. To take the database example,
suppose that you have a C# property declaration that looks like this:
[FieldName("SocialSecurityNumber")]
public string SocialSecurityNumber
{
get {
// etc.
When the C# compiler recognizes that this property has an attribute applied to it (FieldName), it will start
by appending the string Attribute to this name, forming the combined name FieldNameAttribute. The
compiler will then search all the namespaces in its search path (those namespaces that have been mentioned
in a using statement) for a class with the specified name. Note that if you mark an item with an attribute
whose name already ends in the string Attribute, the compiler will not add the string to the name a second
time; it will leave the attribute name unchanged. Therefore, the preceding code is equivalent to this:
[FieldNameAttribute("SocialSecurityNumber")]
public string SocialSecurityNumber
{
get {
// etc.
The compiler expects to find a class with this name, and it expects this class to be derived directly or
indirectly from System.Attribute. The compiler also expects that this class contains information that
governs the use of the attribute. In particular, the attribute class needs to specify the following:
➤
➤
➤
➤
The types of program elements to which the attribute can be applied (classes, structs, properties,
methods, and so on)
Whether it is legal for the attribute to be applied more than once to the same program element
Whether the attribute, when applied to a class or interface, is inherited by derived classes and
interfaces
The mandatory and optional parameters the attribute takes
If the compiler cannot find a corresponding attribute class, or if it finds one but the way that you have used
that attribute does not match the information in the attribute class, the compiler will raise a compilation
www.it-ebooks.info