How to combine Decorator template with C # MEF?

Question

I am trying to improve my current installed assemblies that use C # MEF. Since these assemblies are already used in production, changing individual classes directly is NOT a viable approach at the moment. First of all, I am adding new behavior to existing ones. For example, I have:

public IExtension { Object Execute(); } public BaseExtension : IExtension { // other methods and members public virtual Object Execute() { // do operations here. } } [Export(typeof(IExtension)] public AppRecordExtension : BaseExtension { // .. other methods and members public override Object Execute() { base.Execute(); // shown just for example.. this.someOperation(); } } // other extensions made. 

Now the above works when the MEF container calls the extension in the driver:

 [ImportMany(typeof(IExtension)] private IEnumerable<Lazy<IExtension>> operations; public void ExecuteExtensions() { var catalog = new AggregateCatalog( new AssemblyCatalog(Assembly.GetExecutingAssembly()), new DirectoryCatalog("extensions", ".dll")); CompositionContainer container = new CompositionContainer(catalog); container.ComposeParts(this); Dictionary<IExtension, object> result = new Dictionary<IExtension, object>(); foreach(Lazy(IExtension> extension in operations) { result.Add((extension.Value, extension.Value.Execute()); } } 

However, if I want to implement specific decorators for IExtension or BaseExtension, I don’t understand where I should put them in the container, or how I should put attributes on decorators so that all IExtension source classes load and execute with additional behavior. IExtension decorator example:

 // do I put an attribute here? // if an attribute is put here, how does the MEF container call it? public BatchableExtension : BaseExtension { private IExtension extension = null; public BatchableExtension( IExtension extension) { this.extension = extension; } public override Object Execute() { this.extension.Execute(); doSomeBatchSpecificOperation(); } } // do I put an attribute here? // if an attribute is put here, how does the MEF container call it? public MonitoringExtension : BaseExtension { private IExtension extension = null; public MonitoringExtension( IExtension extension) { this.extension = extension; } public override Object Execute() { this.extension.Execute(); doSomeMonitoringSpecificOperation(); doSomeMoreBehaviors(); } 

Can anyone help here? I want to make sure that when the container raises extensions, the new behavior is also selected, depending on the parameters passed (for example, if isBatchable = true, adds BatchableExtension, etc.). If it were a non-MEF, the above would look something like this:

  public void Main(String[] args) { IExtension ext = new AppRecordExtension(); // this is the part where I want to simulate when I use MEF. IExtension ext2 = new MonitoringExtension(new BatchableExtension(ext)); ext2.Execute(); } 

Answer 1

MEF does not support this functionality, so you have to do it yourself. You can provide data for building a decorated object using Export Metadata - then you will export your extensions as follows:

 [ExtensionExport(IsBatch = true, IsMonitoring = false)] public AppRecordExtension : BaseExtension { // ... } 

and in the class that imports the extensions:

 [ImportMany] private IEnumerable<Lazy<IExtension, IExtensionMetadata>> operations; public void ExecuteExtensions() { // ... foreach(Lazy(IExtension, IExtensionMetadata> extension in operations) { IExtension decoratedExtension = DecorateExtension(extension); result.Add(decoratedExtension, decoratedExtension.Execute()); } } private IExtension DecorateExtension(Lazy<IExtension, IExtensionMetadata> exportedExtension) { IExtension ext = exportedExtension.Value; if (exportedExtension.Metadata.IsBatch) { ext = new BatchableExtension(ext); } if (exportedExtension.Metadata.IsMonitoring) { ext = new MonitoringExtension(ext); } // Other decorating logic... return ext; } 

Answer 2

U can easily add basic support. U just needs a special directory that rewrites the contracts the way you need the decoration to happen:

 public class DecoratorChainCatalog : ComposablePartCatalog { private List<Type> myDecoratorChain; private List<ComposablePartDefinition> myParts; private string myContractName; public DecoratorChainCatalog( Type contract ) : this( AttributedModelServices.GetContractName( contract ) ) { } public DecoratorChainCatalog( string contract ) { Contract.RequiresNotNullNotEmpty( contract, "contract" ); myContractName = contract; myDecoratorChain = new List<Type>(); myParts = new List<ComposablePartDefinition>(); } public void Add( Type type ) { Contract.Invariant( !myParts.Any(), "Recomposition not supported" ); myDecoratorChain.Add( type ); } public override IQueryable<ComposablePartDefinition> Parts { get { ComposeDecoration(); return myParts.AsQueryable(); } } [SecuritySafeCritical] private void ComposeDecoration() { if ( myParts.Any() ) { return; } Trace.WriteLine( "!! ComposeDecoration !!" ); var contracts = new List<string>(); foreach ( var type in myDecoratorChain ) { var originalPart = AttributedModelServices.CreatePartDefinition( type, null ); var importDefs = originalPart.ImportDefinitions.ToList(); if ( type != myDecoratorChain.First() ) { RewriteContract( importDefs, contracts.Last() ); } var exportDefs = originalPart.ExportDefinitions.ToList(); if ( type != myDecoratorChain.Last() ) { contracts.Add( Guid.NewGuid().ToString() ); RewriteContract( exportDefs, type, contracts.Last() ); } // as we pass it to lazy below we have to copy it to local variable - otherwise we create a closure with the loop iterator variable // and this will cause the actual part type to be changed var partType = type; var part = ReflectionModelServices.CreatePartDefinition( new Lazy<Type>( () => partType ), ReflectionModelServices.IsDisposalRequired( originalPart ), new Lazy<IEnumerable<ImportDefinition>>( () => importDefs ), new Lazy<IEnumerable<ExportDefinition>>( () => exportDefs ), new Lazy<IDictionary<string, object>>( () => new Dictionary<string, object>() ), null ); myParts.Add( part ); } // no add possible any longer myDecoratorChain = null; } [SecuritySafeCritical] private void RewriteContract( IList<ImportDefinition> importDefs, string newContract ) { var importToDecorate = importDefs.Single( d => d.ContractName == myContractName ); importDefs.Remove( importToDecorate ); Contract.Invariant( importToDecorate.Cardinality == ImportCardinality.ExactlyOne, "Decoration of Cardinality " + importToDecorate.Cardinality + " not supported" ); Contract.Invariant( ReflectionModelServices.IsImportingParameter( importToDecorate ), "Decoration of property injection not supported" ); var param = ReflectionModelServices.GetImportingParameter( importToDecorate ); var importDef = ReflectionModelServices.CreateImportDefinition( param, newContract, AttributedModelServices.GetTypeIdentity( param.Value.ParameterType ), Enumerable.Empty<KeyValuePair<string, Type>>(), importToDecorate.Cardinality, CreationPolicy.Any, null ); importDefs.Add( importDef ); } [SecuritySafeCritical] private void RewriteContract( IList<ExportDefinition> exportDefs, Type exportingType, string newContract ) { var exportToDecorate = exportDefs.Single( d => d.ContractName == myContractName ); exportDefs.Remove( exportToDecorate ); var exportDef = ReflectionModelServices.CreateExportDefinition( new LazyMemberInfo( exportingType ), newContract, new Lazy<IDictionary<string, object>>( () => exportToDecorate.Metadata ), null ); exportDefs.Add( exportDef ); } } 

See also: http://blade.codeplex.com/SourceControl/latest#src/Blade.Core/Composition/DecoratorChainCatalog.cs