I have written that the newly redesigned Code Weaver now support type-level advices (well, to be precise, type-level join points). The first implementation is the new
in PostSharp Laos.
So what's aggregation?
Say you want to implement a collection (ICollection
) based on an ArrayList
, but you want to hide ArrayList and don't want to implement each method manually. PostSharp can do it for you.
Look at the following code sample:
internal class AggregatedCollection
After processing by PostSharp, the AggregatedCollection
class will implement the ICollection
collection using the ArrayList
Looks magic? If you inspect the generated code (the Roeder's Reflector is always useful for this), you will see a new field ~aggregated~0
of type ICollection
and all methods of this interface, for instance:
The aggregated object is constructed inside the constructor of AggregatedCollection:
this.~aggregated~0 = (ICollection)
Still looks magic?
The ones who already use the Code Weaver will maybe get angry but that's something I needed to do before going beta: I have redesigned quite deeply the low-level code weaver. Most changes are documented in the CHANGELOG.txt file.
So what has changed?
First, the notions of local and global advices has been deprecated. There is instead a unified notion of method-level advices and unified semantics to express what is called elsewhere
, i.e. to apply advices to join points. When you add an advice to the weaver, you can now specify on which methods
it applies and on which operands
. We use the IEnumerable interface to pass sets of methods and operands, so it should be forward compatible with C# 3.0 / LINQ.
If I said method-level advices, that's because PostSharp now supports also type-level advices: the only join point currently supported is after instance construction
, i.e. in the constructor, just after the base constructor has been called.
Secondly, you cannot call the weaver for individual methods. The Weave
method now weaves the complete module according to the advices that were previously added to it.
And finally, the IAdviceProvider
has changed. There is now a single ProvideAdvices
method in which you should add advices to the given weaver. That's all.
The internal workings have been considerably optimized to work with operand-sensitive join points. Say you want to intercept all calls to the Thread.Sleep()
method. You create an advice and apply it to the join points of kind InsteadOfCall
with operand Thread.Sleep
. Before redesign, the weaver would have woven every method of the module. But now, it will only weave methods that effectively use the Thread.Sleep
In order to make it possible, I have implemented the new task IndexUsagesTask
, which reads all method bodies an indexes 'uses' and 'used-by' relationships. Why is it better than the previous design? First, because inspection algorithm of this task is much simpler than the one of the weaver. Secondly, because the same information can be used by other tasks.
So at the end of the day, will you be still angry of this design change? Hopefully not, because these changes don't affect your code too much. All you have to do is to change your implementation of IAdviceProvider
. And this new design is much better and is prepared for the future.
So let's go!
I wrote in the previous post that PostSharp now offers more possibilities for the host to customize the execution process, for instance phased execution and events. In order to enable it, we missed a functionality: to be able to run host code in the PostSharp application domain, not only in the host AppDomain.
This is the role of the new concept of
. The local host is an object that resides in the PostSharp application domain between
and the host object residing in the host application domain (IPostSharpHost
). The whole communication between the PostSharpObject
and the remote host now goes through the local host. We provide a default implementation in the PostSharpLocalHost
class, but you can override it and pass your own implementation using the LocalHostImplementation
property of the PostSharpObjectSettings