Declaring Exports 声明导出
Composable Parts declare exports through the
[System.ComponentModel.Composition.ExportAttribute] attribute. In MEF there are several different ways to declare exports including at the Part level, and through Properties and Methods.
Composable Part exports 可组合部分的导出的声明形式
A Composable Part level export is used when a Composable Part needs to export itself. In order for a Composable Part to export itself, simply decorate the Composable Part with a [System.ComponentModel.Composition.ExportAttribute] attribute as is shown in the code snippet below.[Export] public class SomeComposablePart { ... }
<Export()> Public Class SomeComposablePart ... End Class
Property exports 属性导出的声明形式
Parts can also export properties. Property exports are advantageous for several reasons.- They allow exporting sealed types such as the core CLR types, or other third party types.
- They allow decoupling the export from how the export is created. For example exporting the existing HttpContext which the runtime creates for you.
- They allow having a family of related exports in the same Composable Part, such as a DefaultSendersRegistry Composable Part that exports a default set of senders as properties.
public class Configuration { [Export("Timeout")] public int Timeout { get { return int.Parse(ConfigurationManager.AppSettings["Timeout"]); } } } [Export] public class UsesTimeout { [Import("Timeout")] public int Timeout { get; set; } }
Public Class Configuration <Export("Timeout")> Public ReadOnly Property Timeout() As Integer Get Return Integer.Parse(ConfigurationManager.AppSettings("Timeout")) End Get End Property End Class <Export()> Public Class UsesTimeout <Import("Timeout")> Public Property Timeout() As Integer End Class
Method exports 方法导出的声明形式
A method export is where a Part exports one its methods. Methods are exported as delegates which are specified in the Export contract. Method exports have several benefits including the following.- They allow finer grained control as to what is exported. For example, a rules engine might import a set of pluggable method exports.
- They shield the caller from any knowledge of the type.
- They can be generated through light code gen, which you cannot do with the other exports.
In the example below, the MessageSender class exports its Send method as an Action<string> delegate. The Processor imports the same delegate.
public class MessageSender { [Export(typeof(Action<string>))] public void Send(string message) { Console.WriteLine(message); } } [Export] public class Processor { [Import(typeof(Action<string>))] public Action<string> MessageSender { get; set; } public void Send() { MessageSender("Processed"); } }
Public Class MessageSender <Export(GetType(Action(Of String)))> Public Sub Send(ByVal message As String) Console.WriteLine(message) End Sub End Class <Export()> Public Class Processor <Import(GetType(Action(Of String)))> Public Property MessageSender() As Action(Of String) Public Sub Send() MessageSender()("Processed") End Sub End Class
You can also export and import methods by using a simple string contract. For example below the "Sender" contract is used.
public class MessageSender { [Export("MessageSender")] public void Send(string message) { Console.WriteLine(message); } } [Export] public class Processor { [Import("MessageSender")] public Action<string> MessageSender { get; set; } public void Send() { MessageSender("Processed"); } }
Public Class MessageSender <Export("MessageSender")> Public Sub Send(ByVal message As String) Console.WriteLine(message) End Sub End Class <Export()> Public Class Processor <Import("MessageSender")> Public Property MessageSender() As Action(Of String) Public Sub Send() MessageSender()("Processed") End Sub End Class
Note: When doing method exports, you are required to either provide a type or a string contract name, and cannot leave it blank.
Inherited Exports
MEF supports the ability for a base class / interface to define exports which are automatically inherited by implementers. This is ideal for integration with legacy frameworks which want to take advantage of MEF for discovery but do not want to require modifying existing customer code. In order to provide this capability use the System.ComponentModel.Composition.InheritedExportAttribute. For example below ILogger has an InheritedExport. Logger implements ILogger thus it automatically exports ILogger.[InheritedExport] public interface ILogger { void Log(string message); } public class Logger : ILogger { public void Log(string message); }
<InheritedExport()> Public Interface ILogger Sub Log(ByVal message As String) End Interface Public Class Logger Implements ILogger Public Sub Log(ByVal message As String) Implements ILogger.Log End Sub End Class