C# 4 and .NET 4

336 ❘ ChaPTer 14 reflectiOn
code; in this case the attribute can be placed anywhere in your source code, but needs to be prefixed with
the Assembly or Module keyword:
[assembly:SomeAssemblyAttribute(Parameters)]
[module:SomeAssemblyAttribute(Parameters)]
When indicating the valid target elements of a custom attribute, you can combine these values using the
bitwise OR operator. For example, if you want to indicate that your FieldName attribute can be applied to
both properties and fields, you would write:
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field,
AllowMultiple=false,
Inherited=false)]
public class FieldNameAttribute: Attribute
You can also use AttributeTargets.All to indicate that your attribute can be applied to all types of
program elements. The AttributeUsage attribute also contains two other parameters, AllowMultiple
and Inherited. These are specified using the syntax of =, instead of
simply giving the values for these parameters. These parameters are optional — you can omit them if
you want.
The AllowMultiple parameter indicates whether an attribute can be applied more than once to the
same item. The fact that it is set to false here indicates that the compiler should raise an error if it sees
something like this:
[FieldName("SocialSecurityNumber")]
[FieldName("NationalInsuranceNumber")]
public string SocialSecurityNumber
{
// etc.
If the Inherited parameter is set to true, an attribute applied to a class or interface will also automatically
be applied to all derived classes or interfaces. If the attribute is applied to a method or property, it will
automatically apply to any overrides of that method or property, and so on.
specifying attribute Parameters
This section examines how you can specify the parameters that your custom attribute takes. The way it
works is that when the compiler encounters a statement such as the following,
[FieldName("SocialSecurityNumber")]
public string SocialSecurityNumber
{
// etc.
the compiler examines the parameters passed into the attribute — which is a string — and looks for
a constructor for the attribute that takes exactly those parameters. If the compiler finds an appropriate
constructor, the compiler will emit the specified metadata to the assembly. If the compiler does not find an
appropriate constructor, a compilation error occurs. As discussed later in this chapter, reflection involves
reading metadata (attributes) from assemblies and instantiating the attribute classes they represent.
Because of this, the compiler must ensure that an appropriate constructor exists that will allow the runtime
instantiation of the specified attribute.
In the example, you have supplied just one constructor for FieldNameAttribute, and this constructor takes
one string parameter. Therefore, when applying the FieldName attribute to a property, you must supply one
string as a parameter, as was done in the preceding sample code.
If you want to allow a choice of what types of parameters should be supplied with an attribute, you can
provide different constructor overloads, although normal practice is to supply just one constructor and use
properties to define any other optional parameters, as explained next.
www.it-ebooks.info