How-to：应用mef 提高程序扩展能力（part3）

三、引申扩展

STEP 1:

To make things more interesting, lets add another implementation of IOutputString that is a bit more creative.

   1: [Export(typeof(IOutputString))]

   2: public class ReverseOutputter : IOutputString

   3: {

   4:  

   5:     public void OutputString(string value)

   6:     {

   7:         foreach (var s in value.Split().Reverse())

   8:         {

   9:             Console.ForegroundColor = (ConsoleColor)(s.Length % 10);

  10:             Console.Write(s + " ");

  11:         }

  12:         Console.WriteLine();

  13:     }

  14: }

Just running this now would give us an error right, because we told MEF we wanted exactly one IOutputString... if we change our code to work with multiple we get more fun! 

STEP 2:

In line 7 we changed to request a set of IOutputStrings and in line 19 we changed to loop through all the output devices. 

   1: class Program

   2: {

   3:     [Import]

   4:     public IEnumerable<string> Messages { get; set; }

   5:  

   6:     [Import]

   7:     public IEnumerable<IOutputString> OutputSet { get; set; }

   8:  

   9:     public void Run()

  10:     {

  11:         var catalog = new AggregatingComposablePartCatalog();

  12:            catalog.Catalogs.Add (new DirectoryPartCatalog(@"..\..\..\ExternalMessages\bin\Debug"));

  13:            catalog.Catalogs.Add(new DirectoryPartCatalog(@"..\..\..\ExtraMessages"));

  14:            catalog.Catalogs.Add (new AttributedAssemblyPartCatalog(Assembly.GetExecutingAssembly()));

  15:         var container = new CompositionContainer(catalog.CreateResolver());

  16:         container.AddPart(this);

  17:         container.Compose();

  18:  

  19:         foreach (var Out in OutputSet)

  20:         {

  21:             foreach (var s in Messages)

  22:             {

  23:                 Out.OutputString(s);

  24:             }

  25:         }

  26:  

  27:     

  28:         Console.ReadKey();

  29:     }

Now when we run it we get all our messages in all our outputs..

输出图示：

STEP 3:

Now the only real logic in our main is the nested foreach loops.  We may very well like to change that in the future as well... so let's see if we can abstract that out using exactly the same techniques we have talked about already. 

   1: class Program

   2: {

   3:     [Import]

   4:     public IEnumerable<string> Messages { get; set; }

   5:  

   6:     [Import]

   7:     public IEnumerable<IOutputString> OutputSet { get; set; }

   8:  

   9:     [Import("OutputMessages")]

  10:     public Action<IEnumerable<IOutputString>, IEnumerable<string>> OutputMessages { get; set; }

  11:  

  12:     public void Run()

  13:     {

  14:         var catalog = new AggregatingComposablePartCatalog();

  15:            catalog.Catalogs.Add (new DirectoryPartCatalog(@"..\..\..\ExternalMessages\bin\Debug"));

  16:            catalog.Catalogs.Add(new DirectoryPartCatalog(@"..\..\..\ExtraMessages"));

  17:            catalog.Catalogs.Add (new AttributedAssemblyPartCatalog(Assembly.GetExecutingAssembly()));

  18:         var container = new CompositionContainer(catalog.CreateResolver());

  19:         container.AddPart(this);

  20:         container.Compose();

  21:  

  22:  

  23:         OutputMessages(OutputSet, Messages); 

  24:         

  25:     }

First, in line 9-10 we define an Action that can do the output... and in line 23 we remove our nested foreach loops and replace it with a call to this method.  Now all we have in our Main is effectively wiring up components.  Very loosely coupled!

STEP 4:

Now let's add an option for how the messages are outputted.   It would be very easy to define a config file option for selecting these and returning the correct one.  Notice that MEF knows that this method follows the contract of the Action delegate above, so it does all the wireup for us. 

   1: [Export("OutputMessages")]

   2: public void OutputByMessage(IEnumerable<IOutputString> outputSet, IEnumerable<string> messages)

   3: {

   4:     foreach (var s in messages)

   5:     {

   6:         foreach (var Out in outputSet)   

   7:         {

   8:             Out.OutputString(s);

   9:         }

  10:     }

  11:     Console.ReadKey();

  12: }

I would love to hear what you think?  Can you think of usage for MEF in your applications?    I'd also love for you to grab the final sample and see how many different ways you can extend it..   Enjoy!