Using the Managed Extensibility Framework (MEF) to Develop Modular Silverlight Applications

The MEF library appeared relatively recently, but quickly gained popularity among .Net developers for its ease of use and efficiency. It allows you to build modular applications with a minimum level of connectivity parts (parts) of the application. This library includes not only the Dependency Injection container, but a large amount of infrastructure: a variety of mechanisms for searching for composition elements in assemblies, remote XAP files, a mechanism for marking composition elements using .Net attributes, etc.

There is a version of the MEF for Silverlight, which is different from the desktop version. We will talk about the features of using MEF for Silverlight applications in this article.

Differences from the desktop version

Several specific classes have been added to MEF for Siverlight.

CompositionInitializer
DeploymentCatalog
Compositionhost
ExportFactory <T>

CompositionInitializer

In Silverlight, MEF developers propose to use the CompositionInitializer class (the System.ComponentModel.CompositionInitialization.dll library), which allows you to create a composition for a specific object, initializing all imports of this object and other dependent entities. This functionality is especially important for Silverlight applications, where the decentralization of the component elements of an application is particularly pronounced.
')
The first call to the SatisfyImports() method of this class creates a global container that will be used in all further calls to SatisfyImports() . SatisfyImports produces a composition of all objects that are found in the current assembly and all dependent assemblies (that is, within the entire XAP file). Objects instantiated during composition will be in the container until the latter is destroyed, i.e. until the end of the program.

There are several features of using this class:

Classes that call the SatisfyImports() method cannot have the [Export] attribute;
Objects are instantiated only once and stored in a container;
By default, only the current XAP file is subject to composition, which is easy to fix.

Example:

public partial class Shell : UserControl { public MainPage() { ComposeContainer() } private void ComposeContainer() { CompositionInitializer.SatisfyImports( this ); } } * This source code was highlighted with Source Code Highlighter .

DeploymentCatalog

This class is designed to dynamically download XAP files, which allows you to even more decentralize development, reduce the size of the main XAP file, increase the download speed of the application, etc. XAP files are loaded in asynchronous mode, and the developer can subscribe to a notification that the file has finished downloading and handle errors if they exist.

This class is part of the idea of recomposition (re-composing a composition from existing and added parts), carrying out the latter, if there are parts that allow recomposition.

Features of using DeploymentCatalog :

The browser cache is used when the application is offline.
The CompositionHost class must be used (see below).
If there are identical assemblies in different XAP files, DeploymentCatalog will try to add them all to the catalog, which can lead to an exception (exception) if recomposition is not allowed. You should set CopyLocal=False to duplicate assemblies of the entire application or use my extension for VS2010 XapsMinifier
Only the assemblies that are specified in the manifest file are loaded from the XAP directory.
In Out of Browser mode, downloadable assemblies are not cached in the file system.

Example:

private void CancelLoading() { catalog.CancelAsync(); } private void LoadXapFile( string xapPath) { DeploymentCatalog catalog = new DeploymentCatalog(xapPath); catalog.DownloadCompleted += new EventHandler<AsyncCompletedEventArgs>(DownloadCompleted); catalog.DownloadProgressChanged += new EventHandler<DownloadProgressChangedEventArgs>(ProgressChanged); catalog.DownloadAsync(); _aggregateCatalog.Catalogs.Add(catalog); } void DownloadCompleted( object sender, System.ComponentModel.AsyncCompletedEventArgs e) { if (e.Error != null ) throw e.Error; } void catalog_DownloadProgressChanged( object sender, DownloadProgressChangedEventArgs e) { int progress = e.ProgressPercentage; long received = e.BytesReceived; long total = e.TotalBytesToReceive; } * This source code was highlighted with Source Code Highlighter .

Compositionhost

This class is the link between the directories that contain information on the export / import of parts, and the container that contains the composition of parts. This class allows you to override the initial configuration of the application (loading parts only from the current XAP file). It allows you to specify a set of directories, the contents of which will be tracked, and in case of a change (add / delete), the recomposition of existing parts will be called.

Example:

public partial class Shell : UserControl { public MainPage() { ComposeContainer() } private void ComposeContainer() { _aggregateCatalog = new AggregateCatalog( new DeploymentCatalog()); CompositionHost.Initialize(_aggregateCatalog); CompositionInitializer.SatisfyImports( this ); } } * This source code was highlighted with Source Code Highlighter .

ExportFactory <T>

In some situations, you need to create multiple instances of the composition elements. For example, if the application allows the user to create several copies of documents (elements of the composition), then this cannot be achieved by conventional means. Take advantage of ExportFactory <T>.

Example:

[Export] public class DocumentViewModel { [Import] public ExportFactory<IDocument> DocumentFactory { get ; set ; } protected List <IDocument> Documents { get ; set ; } public void CreateDocument() { Documents.Add(DocumentFactory.CreateExport().Value); } } * This source code was highlighted with Source Code Highlighter .

Creating parts of the composition using ExportFactory <T>, the developer takes full responsibility for the lifetime of the created instance. If instances require freeing memory, then you can use the standard Dispose() pattern.

Example:

[Export] public class DocumentViewModel : IDisposable { private bool isDisposed = false ; [Import] public ExportFactory<IDocument> DocumentFactory { get ; set ; } private List <ExportLifetimeContext<IDocument>> ExportLifeTimeContextList { get ; set ; } protected List <IDocument> Documents { get ; set ; } public void CreateDocument() { ExportLifetimeContext<IDocument> LifeTimeContext = DocumentFactory.CreateExport(); ExportListLifeTimeContext.Add(LifeTimeContext); Documents.Add(LifeTimeContext.Value); } public void Dispose() { Dispose( true ); GC.SuppressFinalize( this ); } public void Dispose( bool disposing) { if (isDisposed) return ; if (disposing) { foreach (IDisposable d in ExportLifeTimeContextList) d.Dispose(); } isDisposed = true ; } } * This source code was highlighted with Source Code Highlighter .

An example of the implementation of the mechanism of recomposition

As an example, which reflects the simplicity and power of using MEF in Silverlight applications, I chose the implementation of support for visual themes (Themes) for application controls.

The application must meet the following requirements:

Maintain threads
Have the ability to download third-party XAP files with themes
Downloading an XAP file should update the list of available topics (recomposition)
The choice of topic should lead to a change in the appearance of controls.

Supporting those

To implement support for the themes, I turned to a published project that provides several ready-made sets of themes. From these projects I use xaml files with themes for basic controls.

Each topic is located in a separate assembly of a separate XAP file. Themes themselves are stored as resources and retrieved upon request.

As a mechanism for accessing topics, a class that implements the IThemeLoader interface is IThemeLoader . This class is able to extract the required resources and contains the name of the topic.

Example:

[InheritedExport] public interface IThemeLoader { string Name { get ; } IEnumerable <ResourceDictionary> Resources { get ; } } public class ThemeLoader : ThemeLoaderBase { #region IThemeLoader Members public override string Name { get { return "Accent" ; } } public override IEnumerable <ResourceDictionary> Resources { get { yield return LoadResourceDictionary( "/SLandMEFdevcamp.AccentTheme;component/Style.xaml" ); } } #endregion /* protected virtual ResourceDictionary LoadResourceDictionary(string uri) { return new ResourceDictionary { Source = new Uri(uri, UriKind.Relative) }; } */ } * This source code was highlighted with Source Code Highlighter .

The attribute InheritedExport indicates that all implementations of the interface marked with this attribute should be exported.

Downloading third-party XAP files

To support third-party XAP files, I place the input field of the XAP file address and the start button on the main form of the application. Downloading is done using DeploymentCabinet , which initiates a recomposition.

As soon as the recomposition has occurred, the list of implementations of IThemeLoader will be IThemeLoader and a new list of available themes will be displayed on the UI.

Example:

private AggregateCatalog _aggregateCatalog = null ; private IEnumerable <IThemeLoader> themesLoaders; private void ComposeContainer() { _aggregateCatalog = new AggregateCatalog( new DeploymentCatalog()); CompositionHost.Initialize(_aggregateCatalog); CompositionInitializer.SatisfyImports( this ); } [ImportMany(AllowRecomposition = true )] public IEnumerable <IThemeLoader> ThemesLoaders { get { return themesLoaders; } set { themesLoaders = value ; RaisePropertyChanged( "ThemesLoaders" ); } } private IThemeLoader theme; public IThemeLoader Theme { get { return theme; } set { theme = value ; LoadTheme( value ); RaisePropertyChanged( "Theme" ); } } private void LoadTheme(IThemeLoader themeLoader) { if (themeLoader.Resources == null || !themeLoader.Resources.Any()) return ; App.Current.Resources.MergedDictionaries.Clear(); foreach ( var resourceDict in themeLoader.Resources) App.Current.Resources.MergedDictionaries.Add(resourceDict); } private void Button_Click( object sender, System.Windows.RoutedEventArgs e) { DeploymentCatalog catalog = new DeploymentCatalog(XapUrlTextBox.Text); catalog.DownloadAsync(); _aggregateCatalog.Catalogs.Add(catalog); } * This source code was highlighted with Source Code Highlighter .

In this case, XAP files with themes are located in the same folder as the main XAP file, and therefore you can specify only the name of the XAP file without a full url. For example, SLandMEFdevcamp.AccentTheme.xap, SLandMEFdevcamp.Win7Theme.xap.

The logic of this code is as follows:

When creating a form, the container is initialized ( ComposeContainer() )
The user enters the address of the XAP file in the XapUrlTextBox field and presses the download button. Loading the XAP file results in adding a new implementation of IThemeLoader to the directory and recommending the ThemesLoaders property, which is associated with the ListBox element on the form
If the user selects any ListBox element, a change in the Theme property is generated, which causes the LoadTheme() method to be LoadTheme()
The LoadTheme() method removes all existing resources and adds resources for the topic the user has selected.

The results of the program can be seen here.

Conclusion

MEF has a large number of advantages, among which are recompositions, the absence of a strictly defined place in which parts of the composition should be registered, etc.

MEF for Silverlight has additional features that are not available even in the desktop version, allowing you to build even more flexible programs.

Possibilities of recomposing allow you to change the set of components right during the program operation, which is very important for those cases when dynamic connection / disconnection of functionality, working modules, etc. is required.

Project source code

Source code can be downloaded here .

Upd: The ExportFactory<T> class has ExportFactory<T> added to the desktop version of the library in MEF 2 Preview 2 .

Source: https://habr.com/ru/post/106486/

All Articles