MEF is a library for creating extensible applications in .NET. It allows components to be discovered and used at runtime without configuration. MEF supports loose coupling between applications and plugins/components. Developers can create components independently without access to the application's code, and applications can integrate plugins dynamically without rebuilding. MEF handles component discovery, loading, and composition using attributes and conventions.

1. MEF
Managed Extensibility Framework

2. Overview
• MEF is library for creating extensible applications. It allows applications to discover and use
components without no configuration required.
• MEF can also be used as IOC / DI container but its primarily designed with the goal of developing
extensible application.
• There are other IOC containers like Unity, Ninject, Autofac, Castle Windsor, StructureMap.
• IOC / Other frameworks can be used to achieve extensibility but
• They require too much development and configuration effort. Think of developing extensible application that can adapt to
runtime changes using Castle or Unity. MEF support this out of the Box with no configuration.
• Some of those frameworks are too heavyweight for simple programming model and not full featured.

3. Scenario
• You are developing a large application that needs support for extensibility. Other developers
should be able to extend your application by developing components.
• You want develop your application with loosely coupled plug-in based architecture like Visual
Studio, Microsoft Office, Firefox browser.
• Visual Studio is real world example using MEF to support extensibility.
• Key points
• Your application and components should be decoupled and independent.
• You application does not know about component at compile time. Application should be able to integrate / plugin those
components at runtime without need of rebuilding the application.
• Components does not have access to source code of your application but still can extend / add features to your application.
Application does not have access to component source code.

4. Without MEF and problems
• You develop main application.
• You develop components, include them as a source code in your main application solution, add
them as a reference in your main application and modify application to use them.
• Problems? Problems and Problems (Is your application extensible anymore?)
• Every time a component is developed / updated, main application source code needs to be changed to add reference to that
component and modify code to use that. Statically composed.
• Component developer does not have access to your code and your main application does not have access to component?
• Does Visual Studio and ReSharper extension know each other and have their source code. No. But they still work together.

5. MEF as a Solution
• Decoupling between application and components
• Statically compiled VS dynamically composed
• Known (at compile time) VS Unknown (Discovered at run time)
• Convert your app into Platform

6. How MEF works
Main Application
Import ILogger Catalog
Assemblies
Parts
Composition
Container
MEF
Part A MyLogger
Component
Export ILogger
Contract
ILogger
Key points
• Import
• Export
• Discover and Compose

7. Concepts
• Part: Part known as Export can provide services to other parts and parts known as Import can consume
services by other parts.
• Contract: Parts talk to each other using contract hence parts gets decoupled. Import part specifies
contract that it needs and Export part specifies contract that it provides.
• Import, ImportMany: Attribute applied on Part that creates need.
• Export: Attribute applied on Part that fulfills the need.
• Catalog: Knows where to find exported parts. Discover assemblies at run-time from plugins folder,
discover and load parts. Contains collection of exported parts.
• Compose: Exported and Imported parts are assembles together. Match the exported parts from the
assembly with the parts that want to import / use them

8. Programming Model
• Attribute based programming model
• Apply attributes to your classes, methods, properties, fields and constructor to determine how pieces are composed within
MEF
• Import -> Field, Property, Constructor
• Export -> Class, Method, Property, Field
• Convection based programming model
• Define set of rules that determines what is composed and what is not

9. Demo Application

10. MEF Features

11. Import
• Import
• ImportMany
• Import(AllowRecompsition = true)
• ImportingConstructor
• Lazy<T>
• IPartImportsSatisifiedNotification

12. Metadata support
• Code Samples

13. Catalog
• Type Catalog
• Assembly Catalog
• Directory Catalog
• Aggregate Catalog

14. MEF Re-composition
DirectoryCatalog
CompositionContainer
FileSystemWatcher
Watch for added / modified files
DirectoryCatalog.Refresh
to include added /
modifies assemblies
Issues
DirectoryCatalog.Refresh only works on added / removed assemblies and not updated
assemblies. When assembly is removed from folder, Refresh will only remove
ComposablePartDefination objects from catalog but does not unloaded assembly from
process.
Existing assemblies cannot be updated when main application has loaded those
assemblies. Use Shadow Copy to solve this problem.

15. Facts about MEF
• MEF is open source hosted on CodePlex
• MEF is lightweight (One DLL -> System.Composition.ComponentModel)
• MEF is already shipped with .Net framework
• MEF can be used with any .Net platform. WPF, Silverlight, ASP.NET MVC, WinForms
• MEF has 2 versions
• MEF that is already shipped with .Net Framework (System.Composition.ComponentModel)
• Lightweight version of MEF optimized for static composition scenarios and provides faster composition

16. Question and Answers