MEF lab [How to: Keep implementation details out of a MEF contract assembly by implementing an interface-based event handler]
In the previous post, I showed how to combine .NET 4's "type embedding" capability with the Managed Extensibility Framework (MEF) to create an application that can be upgraded without breaking existing extensions. In that post, I described the notion of a MEF "contract assembly" thusly:
The contract assembly is the place where the public interfaces of an application live. Because interfaces are generally the only thing in a contract assembly, both the application and its extensions can reference it and it can be published as part of an SDK without needing to include implementation details, too.
The idea is pretty straightforward: an application's public API should be constant even if the underlying implementation changes dramatically. Similarly, the act of servicing an application (e.g., patching it, fixing bugs, etc.) should never require updates to its public contract assembly.
Fortunately it's pretty easy to ensure a contract assembly contains only interfaces and .NET Framework classes (which are safe because they're automatically versioned for you). But things get a little tricky when you decide to expose a custom event...
Imagine your application defines an event that needs to pass specific information in its EventArgs. The first thing you'd do is create a subclass - something like MyEventArgs - and store the custom data there. Because the custom event is part of a public interface, it's part of the contract assembly - and because the contract assembly is always self-contained, the definition of MyEventArgs needs to be in there as well. However, while MyEventArgs is probably quite simple, its implementation is... um... an implementation detail [
Okay, no problem, create an IMyEventArgs interface for the custom properties/methods (which is perfectly acceptable for a contract assembly) and then add something like the following to the application (or an extension):
class MyEventArgs : EventArgs, IMyEventArgs
The public interface (in the contract assembly) only needs to expose the following and all will be well:
event EventHandler<IMyEventArgs> MyEvent;
Oops, sorry! No can do:
The type 'IMyEventArgs' cannot be used as type parameter 'TEventArgs' in the generic type or method 'System.EventHandler<TEventArgs>'. There is no implicit reference conversion from 'IMyEventArgs' to 'System.EventArgs'.
The compiler is complaining there's no way for it to know that an arbitrary implementation of IMyEventArgs can always be converted to an EventArgs instance (which is what the TEventArgs generic type parameter of EventHandler<TEventArgs> is constrained to). Because there's not an obvious way to resolve this ambiguity (the implicit keyword doesn't help because "user-defined conversions to or from an interface are not allowed"), you might be tempted to move the definition of MyEventArgs into the contract assembly and pass that for TEventArgs instead. That will certainly work (and it's not the worst thing in the world) but it feels like there ought to be a better way...
And there is! Instead of using a new-fangled generic event handler, we could instead use a classic .NET 1.0-style delegate in our contract assembly:
/// <summary> /// Interface for extensions to MyApplication. /// </summary> public interface IMyContract { /// <summary> /// Simple method. /// </summary> void MyMethod(); /// <summary> /// Simple event with custom interface-based EventArgs. /// </summary> event MyEventHandler MyEvent; } /// <summary> /// Delegate for events of type IMyEventArgs. /// </summary> /// <param name="o">Event source.</param> /// <param name="e">Event arguments.</param> public delegate void MyEventHandler(object o, IMyEventArgs e); /// <summary> /// Interface for custom EventArgs. /// </summary> public interface IMyEventArgs { /// <summary> /// Simple property. /// </summary> string Message { get; } }
With this approach, the contract assembly no longer needs to include the concrete MyEventArgs implementation: the delegate above is strongly-typed and doesn't have the same constraint as EventHandler<TEventArgs>, so it works great! With that in place, the implementation details of the MyEventArgs class can be safely hidden inside the extension (or application) assembly like so:
/// <summary> /// Implementation of a custom extension for MyApplication. /// </summary> [Export(typeof(IMyContract))] public class MyExtension : IMyContract { /// <summary> /// Simple method outputs the extension's name and invokes its event. /// </summary> public void MyMethod() { Console.WriteLine("MyExtension.MyMethod"); var handler = MyEvent; if (null != handler) { handler(this, new MyEventArgs("MyEventArgs")); } } /// <summary> /// Simple event. /// </summary> public event MyEventHandler MyEvent; } /// <summary> /// Implementation of a custom interface-based EventArgs. /// </summary> class MyEventArgs : EventArgs, IMyEventArgs { /// <summary> /// Simple property. /// </summary> public string Message { get; private set; } /// <summary> /// Initializes a new instance of the MyEventArgs class. /// </summary> /// <param name="message">Property value.</param> public MyEventArgs(string message) { Message = message; } }
The sample application I've created to demonstrate this practice in action (a simple executable/contract assembly/extension assembly trio) is quite simple and works just as you'd expect. Here's the output:
MyApplication.Run MyExtension.MyMethod MyEventArgs
[Click here to download the complete source code for the MefContractTricks sample.]
Keeping a MEF application's contract assemblies as pure and implementation-free as possible is a good and noble goal. There may be times when it is necessary to make compromises and allow implementation details to sneak into the contract assembly, but the use of custom event arguments does not need to be one of them!
So instead of being generic - and failing - go retro for the win!