As introduced in the previous post, aspect inheritance allows you to apply an aspect to an abstract or virtual method and to have the aspect automatically get propagated to any method overriding the initial method.

The functionality is implemented inside the “custom attribute multicasting” mechanism, so you can use aspect inheritance even for your custom aspects developed using PostSharp Core.

Note that, by default, aspects are not inherited. You have to explicitly enable inheritance on aspect-definition or -usage level (see below).

Lines of Inheritance

Aspect inheritance is supported on the following elements:

  • When applied on interfaces, aspects will be propagated to any class implementing this interface or any other interface deriving this interface.
  • When applied on unsealed classes, aspects will be propagated to any class derived from this class.
  • When applied on abstract or virtual methods, aspects will be propagated to any method implementing or overriding this method.
  • When applied on interface methods, aspects will be propagates to any method implementing that interface semantic.
  • When applied on parameter or return value of an abstract, virtual or interface method, aspects will be propagated to the corresponding parameter or to the return value of derived methods using the method-level rules described above.
  • When applied on an assembly, aspects will be propagated to all assemblies referencing (directly or not) this assembly.

Read between the lines: aspect inheritance is not supported on events and properties, but it is supported on event and property accessors. The reason of this limitation is that there is actually nothing like “event inheritance” or “property inheritance” in MSIL (events and properties have nearly no existence for the CLR: these are pure metadata intended for compilers). Obviously, aspect inheritance is not supported on fields.

Again, I always talk of “aspect inheritance”, but I should talk of custom attribute inheritance.

Enabling Aspect Inheritance

As I said, aspects are not inherited by default. You have to enable inheritance explicitly. This can be done on the level of the aspect class itself using the MulticastAttributeUsageAttribute: all usages of this aspect will have inheritance enabled.

The following example is an attribute that can be applied on parameters or return values, but that is “inherited”:

[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.ReturnValue]
[MulticastAttributeUsage(MulticastTargets.Parameter | MulticastTargets.ReturnValue,
    Inheritance = MulticastInheritance.Strict)]
[RequirePostSharp("Torch.DesignByContract", "Torch.DesignByContract.CheckNonNull")]

public class NonNullAttribute : MulticastAttribute
{
}

Alternatively, it can be done at usage-level. If the Inheritance property is not defined at aspect definition level, you can specify it when you apply the custom attribute:

[Transaction(AttributeInheritance=MulticastInheritance.Strict)]
public abstract void DeleteCustomer( int id );

Note that, once the MulticastAttributeUsageAttribute.Inheritance property has been set, it cannot be overwritten. The deliberate objective of this limitation is to allow aspect developers to specify how their aspect is legally used.

Strict and Multicast Inheritance

As you noticed, the type of properties Inheritance and AttributeInheritance is the enumeration MulticaseInheritance. This enumeration defines three values: None (no inheritance), Strict and Multicast.

To understand the difference between strict and multicast inheritance, remember the original role of MulticastAttribute: to propagate custom attributes along the lines of containment. So, if you apply a method-level attribute to a type, the attribute will be propagated to all the methods of this types (some methods can be filtered out using specific properties of MulticastAttribute or MulticastAttributeUsageAttribute).

The difference between strict and multicasting inheritance is that, with multicasting inheritance (but not with strict inheritance), even inherited attributes are propagated along the lines of containment.

Consider the following piece of code, where A and B are both method-level aspects.

[A(AttributeInheritance = MulticastInheritance.Strict)]
[B(AttributeInheritance = MulticastInheritance.Multicast)]
public class BaseClass
{
  // Aspect A, B.
  public virtual void Method1();
}


public class DerivedClass : BaseClass
{
  // Aspects A, B.
  public override void Method1() {}
  // Aspect B.

  public void Method2();
}

If you just look at BaseClass, there is no difference between strict and multicasting inheritance. However, if you look at DerivedClass, you see the difference: only aspect B is applied to MethodB.

The multicasting mechanism for aspect A is the following:

  1. Propagation along the lines of containment from BaseClass to BaseClass::Method1.
  2. Propagation along the lines of inheritance from BaseClass::Method1 to DerivedClass::Method.

For aspect B, the mechanism is the following:

  1. Propagation along the lines of containment from BaseClass to BaseClass::Method1.
  2. Propagation along the lines of inheritance from BaseClass::Method1 to DerivedClass::Method2.
  3. Propagation along the lines of inheritance from BaseClass to DerivedClass.
  4. Propagation along the lines of containment from DerivedClass to DerivedClass::Method1 and DerivedClass::Method2.

In other words, the difference between strict and multicasting inheritance is that multicasting inheritance applies containment propagation rules to inherited aspects; strict inheritance does not.

Avoiding Duplicate Aspects

If you read again the multicasting mechanism for aspect B, you will notice that the aspect B is actually applied twice to DerivedClass::Method1: one instance comes from the inheritance propagation from BaseClass::Method1, the other instance comes from containment propagation from DerivedClass. To avoid surprises, PostSharp implements a mechanism to avoid duplicate aspect instances. The rule: if many paths lead from the same custom attribute usage to the same target element, only one instance of this custom attribute is applied to the target element. Attention: you can still have many instances of the same custom attribute on the same target element if they have different origins (i.e. they originate from different lines of code, typically). From PostSharp 1.0, you can enforce uniqueness of custom attribute instances by using MulticastAttributeUsage.AllowMultiple.

Inheritance Across Assemblies

All of the above works of course even if the base element (say BaseClass) is defined in another assembly than the derived element (say DerivedClass). Easier to say than to implement!

Under The Hood

From the point of view of performance, there was two problems to address:

  1. Build-time performance: we cannot afford completely scanning every referenced assembly, even indirectly, to see if it does not contain, by chance, an aspect that has to be inherited.
  2. Assembly size: inheritance can cause an attribute to be applied dozens or hundreds of time… If the original aspect has to be duplicated for every of its targets, this would result in a huge assemblies.

Let’s start with the second problem.

If you use a Laos aspect using PostSharp Laos 1.0, you maybe noticed (using Reflector or System.Reflection) that the aspect is not represented as a custom attribute in the transformed assembly. It is, indeed, most of the time useless to have a custom attribute since what you want is a modification of the method behavior. It was possible to change this behavior and force PostSharp to store the custom attribute using MulticastAttributeUsageAttribute.PersistMetaData. But most of the time, this property was false, so the custom attribute was simply not written to the target assembly.

Things are a little more complex with inherited attributes. In order to keep build-time performance to an acceptable level,we do not want to evaluate all multicasting rules for all referenced assemblies again and again. Once we know that an element has an inheritable attribute, we want this custom attribute to be present on the target elements. That’s where the assembly size problem enters the stage: why having dozens of identical copies of the same custom attribute?

So the second problem is addressed by defining (when we can, i.e when PersistMetaData is false) every attribute once, then to use references to this custom attribute. It does not look like standard .NET, and indeed it is not: if you open the assembly using Reflector and goes to a target element, you will see the custom attribute [HasInheritedAttribute( 1234 )]. This is the reference. Where is the definition? Look on the class named “<>MulticastImplementationDetails“. This class has no code, just a list of custom attributes with identifiers. So PostSharp reads this list of custom attributes at build-time and indexes it so that it can resolve references.

The attribute HasInheritedAttributes has a second role related to our first problem: compile-time performance. The last thing we want is to scan all assemblies for types or methods that may have inheritable aspects. Instead of that, we make a progressive search. The HasInheritedAttributes custom attribute (used without constructor) serves like a flag that means that the assembly has at least one inheritable attribute. So if a referenced assembly does not define HasInheritedAttributes, we do not consider it at all. Then, we only look at classes that are actually the direct ancestor of classes defined in our current assembly. If this class has a HasInheritedAttributes attribute, we should scan methods. The same with methods: if it has an HasInheritedAttribute, we should scan parameters.

The custom attribute HasInheritedAttributes has thus two roles. When applied to a target (assembly, type, method, parameter):

  • it means that at least one target under that target has an inheritable attribute, and therefore helps the discovery process,
  • when one or any integers are passed to its constructor, it serves as a reference to a a custom attribute defined under <>MulticastImplementationDetails.

Now that you have read all these details, you can fully understand that aspect inheritance is not only one of the most powerful features of PostSharp, but also one of its more complex!

Happy PostSharping!

Comments are closed