Why would one want to use AttributeUsage AllowMultiple when creating attributes?

Question

According to a book I'm reading, the AllowMultiple public property of AttributeUsage specifies:

...whether the target can have multiple instances of the attribute applied to it.

Why would I want/not want to use this?

Answer 1

Attributes are meta-data. Typically, you'll want to decorate a member or type with an Attribute in order to track some information about it.

For example, the DescriptionAttribute is used by the PropertyGrid to label a description of a property:

[Description("This is my property")]
public int MyProperty { get; set; }

Most of the time, having more than one description would not make sense.

However, it is possible that a specific attribute makes sense to use more than once. In that case, you'd want to set the Attribute to allow multiple instances of itself tagged to the same attribute.

(Not that I'd do this, but...) Say you made a custom attribute to track major changes to a class. You might want to list this for every major change:

[Changes(Version=1.1, Change="Added Foo Feature")]
[Changes(Version=2.0, Change="Added Bar Feature")]
public class MyClass
{
    // ...

Answer 2

This example might be a little contrived but hopefully it gets the point across.

[Convertable(typeof(Int32)), Convertable(typeof(Double))]
public class Test
{

}

Answer 3

This depends what the attributes are.

For example, you could make an attribute that marks a class as depending on something, and you could allow multiple dependencies.

For a concrete example, look at SuppressMessage, which suppresses a code analysis warning. A member can have multiple warnings that you might want to suppress.

Another example is WebResource; an assembly can contain multiple resources.