What's the point of indicating AllowMultiple=false on an abstract Attribute class?

Question

On a recent question about MVC attributes, someone asked whether using HttpPost and HttpDelete attributes on an action method would result in either request type being allowed or no requests being allowed (since it can't be both a Post and a Delete at the same time). I noticed that ActionMethodSelectorAttribute, from which HttpPostAttribute and HttpDeleteAttribute both derive is decorated with

[AttributeUsage(AttributeTargets.Method,
                AllowMultiple = false,
                Inherited = true)]

I had expected it to not allow both HttpPost and HttpDelete on the same method because of this, but the compiler doesn't complain. My limited testing tells me that the attribute usage on the base class is simply ignored. AllowMultiple seemingly only disallows two of the same attribute from being applied to a method/class and doesn't seem to consider whether those attributes derive from the same class which is configured to not allow multiples. Moreover, the attribute usage on the base class doesn't even preclude your from changing the attribute usage on a derived class. That being the case, what's the point of even setting the values on the base attribute class? Is it just advisory or am I missing something fundamental in how they work?

FYI - it turns out that using both basically precludes that method from ever being considered. The attributes are evaluated independently and one of them will always indicate that the method is not valid for the request since it can't simultaneously be both a Post and a Delete.

Answer 1

Setting AllowMultiple on a base attribute essentially sets a default for all attributes that derive from it. If you wanted all attributes deriving from a base atribute to allow multiple instances then you can save duplication by applying an [AttributeUsage] attribute to this effect to the base attribute avoiding the need to do the same to all the derived attributes.

For example, suppose you wanted to allow this:

public abstract class MyAttributeBase : Attribute
{
}

public sealed class FooAttribute : MyAttributeBase
{
}

public sealed class BarAttribute : MyAttributeBase
{
}

[Foo]
[Foo]
[Bar]
[Bar]
public class A
{
}

As it stands, this generates a compiler error since custom attributes, by default, do not permit multiple instances. Now, you could apply an [AttribteUsage] to both [Foo] and [Bar] like this:

[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public sealed class FooAttribute : MyAttributeBase
{
}

[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public sealed class BarAttribute : MyAttributeBase
{
}

But alternatively, you could instead just apply it to the base attribute:

[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public abstract class MyAttributeBase : Attribute
{
}

public sealed class FooAttribute : MyAttributeBase
{
}

public sealed class BarAttribute : MyAttributeBase
{
}

Both approaches have the same direct effect (multiple instances of both [Foo] and [Bar] are permitted) but the second approach also has the indirect effect that any other attributes deriving from [MyAttribute] will now allow multiple instances unless they have their own [AttributeUsage] that overrides that setting.