MEF Logger – Creating plugins using MEF

• Download MefLoggerSolution - 202.5 KB

Introduction

The goal is to learn how to use the MEF in a very simple way. Let's build a component for recording logs, so important in our applications, and this component should record the logs in different ways, for example, log into the database, Windows event log, file server, etc. The big advantage of a pluggable component is that you can add other loggers without having to modify their application, and it’s quite simple thanks to the MEF team..  

Background

MEF allows us to work with the concept of plugins. It provides a framework that allows us to specify the points where the application may be extended, exposing modules that can be plugged by external components. Rather than explicitly reference the components in the application, the MEF allows our application to find components at runtime, through the composition of parts, managing what it takes to keep these extensions. Thus, our application does not depend on a implementation, but an abstraction and can add new features to a program without the need to recompile, or even, without interrupting its execution.

MEF Architecture (quite simple…)

To build a pluggable application using MEF, we must follow these steps:

1. Define extension points:
   
   The Extension Points, are the "parts" of our application we want to allow extensions. In our example, the extension point is the log writing
   
   
   
2. Define a MEF Contract for each extension point
   
   For each Extension Point set, we need to define a MEF contract that can be: Delegates or interface. In our example we will create a DLL containing the interface that define our MEF Contract
   
   
   
3. Define a class to manage the extension point:
   
   To inform the MEF how to manage our plugins, we use the Import attribute. In our example, the PluginHandler class will manage extensions
   
   
   
4. Create the plugin
   
   To create an extension, we should first implement the MEF Contract to the desired extension point. This extension is known as a MEF Composable Part. To define a class as Composable Part, we use the attribute Export
   
   
   
5. Define a Catalog
   
   The catalog holds, at runtime, a list of all imported Composable Parts. The catalogs can be of types: AssemblyCatalog, DirectoryCatalog, TypeCatalog, DeploymentCatalog. In our example, we use the DirectoryCatalog, who discovers the plugins in a certain directory

Using the code

Our solution will consist of five projects.

Project name	Project type	description	References
MefLogger	Class Library	Main Dll, to be used by your application	MefLogger.Interface
MefLogger.Interface	Class Library	Dll to be used by plugins
MefFileLoggerPlugin	Class Library	Plugin to register log in text files	MefLogger.Interface
MefEventLoggerPlugin	Class Libraryy	Plugin to register log in Windows Event Log	MefLogger.Interface
ApplicationTest	Console	Test application	MefLogger

The solution is based on the following concept

In order to create a pluggable system, we must export an interface that must be implemented by plugins. For this I created a separate project to define the interface: MefLogger.Interface..

The MefLogger project is our component that will use the MEF to export and import the plugin interface, manage and fire commands to the plugins. The interesting thing is that the MefLogger project does not know how to register logs, nor need, are the plugins who need to know how to do this. This project is a DLL that will find and manage plugins, this way, we don’t need to bother on implementing extenstion points in every application we want to implement logging. Just reference the MefLogger DLL in our application..

MefFileLoggerPlugin and MefEventLoggerPlugin Projects are our plugins..

The SampleApp project is a very simple console application that demonstrates the use of MefLogger DLL.

Well, lets to the example.

Create a new blank solution and give it the name of MefLoggerSolution, as in Figure 1

Figure 1

Add a new Class Library project by clicking the right mouse button (for righties) on the solution. Name this project as MefLogger.Interface. This project will contain the contracts of our plugin.

Figure 2

Figure 3

Rename the Class 1 class to IMefLogger. It is a good practice to use the letter "I" at the beginning of the name to identify the class as an interface..

Figure 4 Figure 5

By renaming the class, we will receive the following message:

Figure 6

Clicking the Yes button, Visual Studio will replace all references to the Class 1 name to IMefLogger.

Modify the content of the class for it to be an interface. The code should be equal to the code below::

using System;
namespace MefLogger.Interface
{
    public interface IMefLogger
    {
        void Log(string message);
    }
}

Add a new Class Library project to our solution. Name this project MefLogger. This project will be our main DLL.

Figure 7

Figure 8

Change the Class 1 name for Logger.

Add a new class to the MefLogger project called PluginHandler. This class will be responsible for loading and fire commands to the plugins.s.

Figure 9Figure 9

Figure 10

Now let's add the necessary references. As I didn’t registered the MEF in the GAC, I will add references to the MEF DLLs located in a folder..

Figure 11

Add a reference to the MefLogger.Interface project..

Figure 12

Also add an Application Configuration File and name it MefLogger.dll.config.

Using configuration files in DLL is not trivial.

To achieve this we must follow these steps:

1. Add a New Application Configuration File and name it MefLogger.dll.configig
2. Change the BuildAction property to Content- Change the BuildAction property to Content
3. Change the Copy to Output property to Copy Alwaysys

Figure 13

Modify the MefLogger.dll.config file to be equal as below::

<?xml version="1.0" encoding="utf-8" ?>
<conFiguretion>
  <appSettings>
    <add key ="PluginPath" value="D:\Artigos\MefLoggerSolution\Plugins"/>
  </appSettings>
</conFiguretion>

Now we can write the code needed to use the MEF and manage plugins.

Modify the PluginHandler class so you have the code below::

using System;
using System.Collections.Generic;
// Referências ao MEF
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;
using System.ComponentModel.Composition.Primitives;
using System.ComponentModel.Composition.ReflectionModel;
using System.ComponentModel.Composition.AttributedModel;
//
using MefLogger.Interface;
using System.Reflection;
using System.ConFiguretion;

namespace MefLogger
{
    internal class PluginHandler : IDisposable
    {
        // O atributo ImportMany permite que importemos várias classes que 
        // implementam a mesma interface
        [ImportMany(typeof(IMefLogger))]
        // AddinList armazenará todos os plugins carregados
        public List<IMefLogger> AddinList
        { get; set; }

        // AggregateCatalog armazena os catálogos do MEF 
        AggregateCatalog catalog = new AggregateCatalog();

        public void InitializePlugins()
        {
            // cria a instância da nossa lista de plugins
            AddinList = new List<IMefLogger>();
            // cria um DirectoryCatalog e adiciona ao nosso AggregateCatalog
            catalog.Catalogs.Add(new DirectoryCatalog(GetConFiguretionPath(), "*.dll"));
            // cria o CompositionContainer
            CompositionContainer cc = new CompositionContainer(catalog);
            // Efetua a mágica.... É neste momento que o MEF 
            // carrega os plugins e os adiciona ao nosso AddinList
            cc.ComposeParts(this);
        }

        public void WriteLog(string message)
        {
            // para cada plugin carregado em AddinList
            foreach (IMefLogger l in AddinList)
            {
                // chama o método Log de cada plugin
                l.Log(message);
            }
        }

        private string GetConFiguretionPath()
        {
            /* Utilizar arquivos de conFigureção em DLL não é trivial. 
             * Para conseguir isso devemos seguire os seguintes passos:
             * - Adicionar o arquivo App.Config
             * - Mudar a propriedade BuildAction para Content
             * - Mudar a propriedade Copy to Output para Copy Always
             * - Alterar o nome de App.Config para MefLogger.dll.config
             */
            // Abre o arquivo de conFigureção a partir da pasta onde a DLL está
            ConFiguretion PluginConfig = 
            ConFiguretionManager.OpenExeConFiguretion(
                                    this.GetType().Assembly.Location);
            // Recupera a seção appSettings
            AppSettingsSection PluginConfigAppSettings = 
            (AppSettingsSection)PluginConfig.GetSection("appSettings");
            // retorna o valor da chave PluginPath
            return PluginConfigAppSettings.Settings["PluginPath"].Value; 
            
        }

        public void Dispose()
        {
            catalog.Dispose();
            catalog = null;
            AddinList.Clear();
            AddinList = null;
        }
    }
}

Now, modify the Logger class Logger so you have the code below:

singusing System;

namespace MefLogger
{
    public class Logger : IDisposable
    {
        // Vamos utilizar o padrão Singleton, 
        // para evitar carregar os plugins várias vezes.
        static Logger singletonLogger;
        
        PluginHandler h;
        private Logger()
        {
            h = new PluginHandler();
            h.InitializePlugins();

        }

        // Implementação do padrão Singleton
        public static Logger GetLogger()
        {
            // se a instância da classe Logger não foi criada, então cria.
            if (singletonLogger == null)
                singletonLogger = new Logger();

            return singletonLogger;
        }

        public void Log(string message)
        {
            h.WriteLog(message);
        }

        public void Dispose()
        {
            h = null;
            singletonLogger = null;
        }
    }
}

Just to organize our solution, add a Solution Folder called Plugins. This folder is only logical, so, if you look in Windows Explorer, you will not see this folder. We will use this folder to create the plugins projects.

Figure 14 and  Figure 15

Add into the Plugins folder a new Class Library project named TextLoggerPlugin. In this project, we'll create a plugin to write the log into text file. Add references to the MefLogger.Interface project and the System.ComponentModel.Composition.CodePlex.Dll MEF Dll. For plugins, this is the only required MEF DLL we need to reference..

usingusing System;
using System.ComponentModel.Composition;
using MefLogger.Interface;
using System.IO;

namespace TextLoggerPlugin
{
    [Export(typeof(IMefLogger))]
    public class TextLogger : IMefLogger
    {
        public void Log(string message)
        {
            // o arquivo será criado na pasta onde a aplicação SampleApp estará rodando.
            StreamWriter sw = File.AppendText("addinlog.txt");
            sw.WriteLine(message);
            sw.Close();
        }
    }
}

Figure 16

Let’s now create a new project to another plugin, EventLoggerPlugin, which will record our log in the Windows event log.

usingusing System;
using System.ComponentModel.Composition;
using MefLogger.Interface;
using System.Diagnostics;


namespace EventLoggerPlugin
{
    [Export(typeof(IMefLogger))]
    public class EventLogger : IMefLogger
    {
        string sSource = "";
        string sLog = "";
        string sEvent = "";

        public void Log(string message)
        {
            sSource = "EventLoggerAddin";
            sLog = "Application";
            sEvent = message;

            try
            {
                if (!EventLog.SourceExists(sSource))
                    EventLog.CreateEventSource(sSource, sLog);

                EventLog.WriteEntry(sSource, sEvent);
                EventLog.WriteEntry(sSource, sEvent, EventLogEntryType.Information, 234);
            }
            catch
            {
                // Ocorrerá erro caso não esteja rodando o programa com 
                // permissões de administrador
            }
        }
    }
}

We now need to add a project to test our DLL. Let's add a new Console Application project named SampleApp.

Figure 17

To test our application, we'll just add a reference to the MefLogger project..

Figure 18

Make our SampeApp project as the “StartUp Project”..

Figure 19

Modify the Program class to be this way::

usingusing System;
using MefLogger;

namespace SampleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            Logger _logger = Logger.GetLogger();
            _logger.Log("Log Teste 1");
            _logger.Log("Log Teste 2");
            _logger.Log("Log Teste 3");
            _logger.Dispose();
        }
    }
}

Finally, our solution will look like this:

Figure 20

To run the application, we must, we must create the folder defined in thee MefLogger.dll.config file and copy the dlls created in thee plugins projects there..

You're done..

From this simple example, you, you can modify and tailor it to meet your needs..

Conclusion:

We have seen that the MEF is very simple to use and greatly simplifies the development of pluggable systems..

Points of Interest

MEF site onMEF site on CodePlex: http://mef.codeplex.com/documentation