MEF Factory

A better factory implementation with MEF.

There are many different ways to implement the Factory Design Pattern. In a previous post, I showed how to create a simple factory, a factory using Generics, and an abstract factory.

In this post, I will show what I believe to be a better factory implementation using the Managed Extensibility Framework (MEF). If you are you new to MEF, take a look at this post to learn how it works and why it’s useful.

Scenario

I will demonstrate a MEF factory by building a custom logging library. The library will either log to a file, database or service, and consumers of the logging library will be unaware of the underlying logging implementation. All consumers will instead call the same Logger.Log(string message) method, and allow the factory to determine which logger (file, database or service) should used.

Implementation

We have a simple interface ILogger:

public interface ILogger
{
    void Log(string message);
    Types.StorageMode StorageMode { get; }
}

All loggers will implement this interface, and Export the ILogger type.

[Export(typeof(ILogger))]
internal class FileLogger : ILogger
{
    public Types.StorageMode StorageMode
    {
        get { return Types.StorageMode.File; }
    }

    public void Log(string message)
    {
        Debug.WriteLine(message);
    }
}

Notice that the FileLogger class uses the internal access modifier. This will prevent consumers of the logging library from instantiating this class directly, and instead force them to go through our factory.

Factory

Our factory in this example is really just a public class that also implements the ILogger interface. Since it’s public, consumers of the logging library can instantiate this class.

public class Logger : ILogger
{
	private static IEnumerable<ILogger> _loggers = null;

	public Types.StorageMode StorageMode { get; set; }

	private ILogger LoggingImplementation
	{
		get
		{
			return _loggers
				.Where(l => l.StorageMode == this.StorageMode)
				.First();
		}
	}

	static Logger()
	{
		AggregateCatalog catalog = new AggregateCatalog();
		catalog.Catalogs.Add(new AssemblyCatalog(typeof(ILogger).Assembly));

		CompositionContainer container = new CompositionContainer(catalog);

		_loggers = container.GetExportedValues();
	}

	public Logger()
	{
		StorageMode = Types.StorageMode.File;
	}

	public Logger(Types.StorageMode storageMode)
	{
		StorageMode = storageMode;
	}

	public void Log(string message)
	{
		LoggingImplementation.Log(message);
	}
}

In the static constructor of this class, we search the assembly for logging implementations and store them in the IEnumerable<ILogger> static field. Then when the Log method is called, we query this field using LINQ, finding the correct logging implementation by the StorageMode enum.

Conclusion

This is a very basic example of how MEF can be used in a factory design pattern, and can be extended in many ways. For example, you could extend the library to read an AppSetting to determine which logger to use, add asynchronous invocation to the logger factory, etc.

Download

MEF Factory Example