Page 3 of 6
As well as using the constructor to initialise the instance, you can also use named parameters to initialise member variables. For example, if we add a public variable MoreData to the attribute class:
public class ASCII : Attribute
public string MyData;
public string MoreData;
public ASCII(string MyDataIn)
MyData = MyDataIn;
it can be initialised using:
[ASCII("Hello Attribute World",
Now when GetCustomAttributes is called the instance is constructed as follows:
"Hello Attribute World");
attrs.MoreData = "SomeData";
Once again you can test this assertion by using a MessageBox:
ASCII attrs=(ASCII) typeof(MyClass).
where you will discover that the public string MoreData has indeed been set to “SomeData” by the attribute.
You should now be able to see the general principle:.
- Any unnamed parameters used in the attribute are passed to the constructor in the order in which they are given.
- Any named parameters are used as initialisation statements after the instance has been constructed.
Notice that all of the unnamed parameters have to come before the named parameters. So for example, an attribute applied as:
when the GetCustomAttributes method is used.
Notice also that named parameters are optional, if they are not supplied then the corresponding variable is left uninitialised.
It is also important to know that the type of parameter you can use is limited to the majority of the simple types, i.e. int, long, float, string, System.Type, object, a publicly accessible enum and a one-dimensional array of any allowable type.
You might think that as you can pass an object you can pass anything but this isn’t the case. There is an additional condition that restricts parameters to constants of the appropriate type.
So you can have:
but you can’t have:
or anything like it.
Each time you request the details of an attribute a new object is instantiated no matter what class is involved.
So for example, if we go back to the simpler version of ASCII with a single parameter constructor, the following:
[ASCII("Hello Attribute World")]
public class MyClass
public class MyClass2
does indeed create distinct attribute instances as you can demonstrate:
The result is two messageboxes that correctly show each of the messages set by the attribute tags.
However you get two instances even if you call GetCustomAttributes a second time on the same class.
What isn’t generally realised is that you can change attribute values fairly easily at runtime. The reason is, of course, that the instances of the attribute classes that are created are perfectly normal objects and can be used without restriction. For example, we can get the object:
change the value of its public variable and show that it has changed:
attrs1.MyData="A New String";
and finally create another instance and show that its value is unchanged: