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:

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!

Microsoft PDC 2008 is over, as are American presidential elections. We can now talk about something exiting again and hope it will gain some momentum in the community (thus blogging about boring technical details during PDC was intentional).

It's maybe the most exciting feature of PostSharp after PostSharp itself: aspects are now inheritable.

A code sample worthing a hundred words, here is what is now possible:

public interface IDiary
    Contact TryFindContact([NonEmpty] string name);

    [return: NonNull]
    Contact FindContact([NonEmpty] string name);

    void Update([NotNull] Contact contact);


The aspects (here NonEmpty and NonNull) are applied on methods of an interface... but are effective on all implementations of this interface!

(Oh yes, for this to work correctly, you need to download the latest build from -- the CTP 2 contained some bugs that have been solved in the mean time).

The implementation of these aspects does not use Laos, but a dedicated plug-in that generates optimal MSIL instructions. You can download the plug-in using an SVN client from

The inheritance feature is indeed implemented at the level of MulticastAttribute, and not directly in Laos. It means that you can use it inside any plug-in. But let's now see an example using Laos.

Simple Invariant Checking

Here is an interesting first example of this feature; it is both simple and useful.

We want to check invariants, and we want to do it simply. With PostSharp 1.5, checking invariants can be as simple as implementing an interface, say IConsistant.

public interface IConsistant
    void CheckConsistency();

When an object implements the IConsistant assembly, we want the CheckConsistency method to be "automagically" invoked after each non-private instance method.

It's possible by applying a single custom attribute, say [ConsistantAspect] to the IConsistant interface:

public interface IConsistant

This custom attribute is unbelievably simple:

[AttributeUsage(AttributeTargets.Interface)] [MulticastAttributeUsage(MulticastTargets.Method, TargetMemberAttributes = MulticastAttributes.Public | MulticastAttributes.Protected | MulticastAttributes.Internal | MulticastAttributes.Instance, Inheritance = MulticastInheritance.Multicast)] [Serializable] public sealed class ConsistantAspect : OnMethodBoundaryAspect { public override void OnSuccess(MethodExecutionEventArgs eventArgs) { ((IConsistant) eventArgs.Instance).CheckConsistency(); } }


Basically, we have create an OnMethodBoundaryAspect and we implement the OnSuccess handler that invokes the CheckConsitency method when the target method has successfully completed. The AttributeUsage custom attribute restricts the use of this aspect to interfaces; actually, we will use it only once: on the IConsistant method.

The interesting part if the custom attribute MulticastAttributeUsage on the top of that:

  • The property TargetMemberAttributes is old and known: here we define that we want to apply the aspect only to non-private instance methods.
  • The property Inheritance is the new and interesting one: the value Multicast means that the aspect should be inherited (from the interface to classes implementing the interface) and then multicast to all methods matching TargetMemberAttributes.

As a result, when we implement the interface and have invariants checked automatically:

class Cashbox : IConsistant
    public decimal Balance { get; private set; }

    public void Debit(decimal amount)
        this.Balance -= amount;

    public void Credit(decimal amount)
        this.Balance += amount;

    public void CheckConsistency()
        if ( Balance < 0 )
            throw new Exception("Invalid balance.");


As you can see, no aspect is directly applied on Cashbox or on its methods. Aspects are inherited from IConsistant and then propagated to all public instance methods.

I'll blog more about this feature later.

Happy PostSharping!


Would I be a perfect .NET developer if I did not blog about Windows Azure? I let the response to your own judgment, but even if you don't agree on that statement read on.

If you try to deploy a PostSharp-enabled assembly into the Development Fabric, you will probably get the following exception:

[SecurityException: Request for the permission of type 'System.Security.Permissions.SecurityPermission, mscorlib, Version=, Culture=neutral, PublicKeyToken=b77a5c561934e089' failed.]
   System.Runtime.Serialization.Formatters.Binary.ObjectReader.CheckSecurity(ParseRecord pr) +10107255
   System.Runtime.Serialization.Formatters.Binary.ObjectReader.ParseArray(ParseRecord pr) +155
   System.Runtime.Serialization.Formatters.Binary.ObjectReader.ParseObject(ParseRecord pr) +151
   System.Runtime.Serialization.Formatters.Binary.__BinaryParser.ReadArray(BinaryHeaderEnum binaryHeaderEnum) +581
   System.Runtime.Serialization.Formatters.Binary.__BinaryParser.Run() +283
   System.Runtime.Serialization.Formatters.Binary.ObjectReader.Deserialize(HeaderHandler handler, __BinaryParser serParser, Boolean fCheck, Boolean isCrossAppDomain, IMethodCallMessage methodCallMessage) +559
   System.Runtime.Serialization.Formatters.Binary.BinaryFormatter.Deserialize(Stream serializationStream, HeaderHandler handler, Boolean fCheck, Boolean isCrossAppDomain, IMethodCallMessage methodCallMessage) +326
   System.Runtime.Serialization.Formatters.Binary.BinaryFormatter.Deserialize(Stream serializationStream) +33
   PostSharp.Laos.Serializers.BinaryLaosSerializer.Deserialize(Stream stream) in BinaryLaosSerializer.cs:46
   PostSharp.Laos.LaosSerializer.Deserialize(Assembly assembly, String resourceName) in LaosSerializer.cs:68
   ~PostSharp~Laos~Implementation..cctor() +365

Don't panic, it is not the end of the story.

Clearly, there is a security exception. Looking at the stack trace, you see that the exception occurs in the BinaryFormatter.Deserialize. Indeed, the binary formatter requires full trust and... code running inside Windows Azure is only partially trusted.

I could have written the same for code running inside SQL Server 2005, but it's less hyped: very often, when your code is hosted, it is not granted full trust.

Pluggable Serializers

If you are new to PostSharp, you may wonder why BinaryFormatter is invoked at runtime. In fact, at build time, aspects are instantiated and serialized into a binary stream. This stream is stored in a managed resource in the assembly and deserialized at runtime. That's why the binary formatter is invoked.

Fortunately, PostSharp 1.5 CTP 2 comes with a new feature called pluggable serializers. Before, you had no choice: aspects were always serialized using the BinaryFormatter. It is the best tool for the job for most situations, but, as you can see here with partial-trust scenarios, it is not always possible to use it.

But there are other serializers in .NET, isn't it? So why not to use them? That's exactly the idea behind pluggable serializers: you can now choose the serializer used to to serialize aspects at build time and deserialize them at rutime.

PostSharp 1.5 comes with three serializers: BinaryLaosSerializer (relying on BinaryFormatter), XmlLaosSerializer (relying on XmlSerializer) and StateBagSerializer (requiring manual implementation in all classes, see documentation). All implement the abstract class PostSharp.Laos.Serializer; if you need another serializer, you can develop your.

Once you have selected a serializer, you should tell PostSharp to use it for your aspect. This is done by applying the custom attribute LaosSerializerAttribute to your aspect class. For instance:

public class SomeAspect : OnMethodBoundaryAspect
[XmlElement] public string Name;
public override void OnEntry(MethodExecutionEventArgs eventArgs) { } }

Since this serializer does not require full trust... it simply works in Windows Azure!

Why do I need a serializer, anyway?

Excellent remarks. Serializers are good when there there is some non-trivial state to be stored. But if your aspect is an isolated custom attribute with some public fields or public properties, it is far better to instantiate the attribute at runtime using the values provided to construct the custom attribute.

For instance, if a custom attribute instance is defined by:

[SomeAspect(Name = "Hello")]

It would be much better (faster and byte-wise more compact) to create the aspect using the following code:

SomeAspect instance = new SomeAspect { Name = "Hello" };

This is exactly what happens if you use the custom attribute LaosSerializerAttribute and pass null to the constructor parameter. The aspect won't be serialized; it will be instantiated and initialized at runtime by some auto-generated code. And this is actually the way aspects for Compact Framework and Silverlight work.

So remember: even if you don't write partially trusted code, you can still use the "null serializer" to improve the size and performance of your assemblies.

Happy PostSharping!