CompositionContainer
Class
Definition
Manages the composition of parts.
public class CompositionContainer : System.ComponentModel.Composition.Hosting.ExportProvider, IDisposable, System.ComponentModel.Composition.ICompositionService
- Inheritance
- Implements
Inherited Members
System.ComponentModel.Composition.Hosting.ExportProvider
System.Object
Examples
In the following example, a CompositionContainer object is initialized with a catalog and is used to fill the imports of a part. This example uses the Attributed Programming Model.
[Export]
class MyAddin
{
public String myData { get { return "The data!"; } }
}
class MyProgram
{
[Import]
public MyAddin myAddin { get; set; }
}
class Program
{
static void Main(string[] args)
{
AggregateCatalog catalog = new AggregateCatalog();
catalog.Catalogs.Add(new AssemblyCatalog(typeof(MyAddin).Assembly));
CompositionContainer _container = new CompositionContainer(catalog);
MyProgram myProgram = new MyProgram();
_container.SatisfyImportsOnce(myProgram);
Console.WriteLine(myProgram.myAddin.myData);
Console.ReadLine();
_container.Dispose();
}
}
<Export()>
Public Class MyAddin
Public ReadOnly Property theData As String
Get
Return "The Data!"
End Get
End Property
End Class
Public Class MyProgam
Private _MyAddin As MyAddin
<Import()>
Public Property MyAddinProperty As MyAddin
Get
Return _MyAddin
End Get
Set(ByVal value As MyAddin)
_MyAddin = value
End Set
End Property
End Class
Sub Main()
Dim catalog As AggregateCatalog = New AggregateCatalog()
catalog.Catalogs.Add(New AssemblyCatalog(GetType(MyAddin).Assembly))
Dim container As CompositionContainer = New CompositionContainer(catalog)
Dim theProgam As MyProgam = New MyProgam()
container.SatisfyImportsOnce(theProgam)
Console.WriteLine(theProgam.MyAddinProperty.theData)
Console.ReadLine()
container.Dispose()
End Sub
Remarks
A CompositionContainer object serves two major purposes in an application. First, it keeps track of which parts are available for composition and what their dependencies are, and performs composition whenever the set of available parts changes. Second, it provides the methods by which the application gets instances of composed parts or fills the dependencies of a composable part.
Important
This type implements the IDisposable interface. When you have finished using the type, you should dispose of it either directly or indirectly. To dispose of the type directly, call its Dispose method in a try/catch block. To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.
Parts can be made available to the container either directly or through the Catalog property. All the parts discoverable in this ComposablePartCatalog are available to the container to fulfill imports, along with any parts added directly.
The Compose method allows instantiated parts to be added to an existing container. Assuming composition is successful, these parts will have their imports filled with parts retrieved from the container, and their exports will be available to other parts. Imports marked as recomposable will be registered for recomposition.
The SatisfyImportsOnce method allows a part to have its imports filled without being added to the container. If the composition is successful, the part's imports will be filled, but the part's exports will not be available to other parts and no imports will be registered for recomposition.
CompositionContainer objects should always be disposed. When the Dispose method is called, the CompositionContainer object also disposes all the parts that it has created.
A CompositionContainer object that can be accessed from multiple threads must be constructed with the isThreadSafe parameter set to true, using the CompositionContainer(ComposablePartCatalog, Boolean, ExportProvider[]) constructor. Performance will be slightly slower when isThreadSafe is true, so we recommend that you set this parameter to false in single-threaded scenarios. The default is false.
Warning
A CompositionContainer should never import itself, or a part that has a reference to it. Such a reference could allow an untrusted part to gain access all the parts in the container.
Constructors
| CompositionContainer() |
Initializes a new instance of the CompositionContainer class. |
| CompositionContainer(ExportProvider[]) |
Initializes a new instance of the CompositionContainer class with the specified export providers. |
| CompositionContainer(CompositionOptions, ExportProvider[]) |
Initializes a new instance of the CompositionContainer class with the specified export providers and options. |
| CompositionContainer(ComposablePartCatalog, ExportProvider[]) |
Initializes a new instance of the CompositionContainer class with the specified catalog and export providers. |
| CompositionContainer(ComposablePartCatalog, Boolean, ExportProvider[]) |
Initializes a new instance of the CompositionContainer class with the specified catalog, thread-safe mode, and export providers. |
| CompositionContainer(ComposablePartCatalog, CompositionOptions, ExportProvider[]) |
Initializes a new instance of the CompositionContainer class with the specified catalog, options, and export providers. |
Properties
| Catalog |
Gets the ComposablePartCatalog that provides the container access to Export objects. |
| Providers |
Gets the export providers that provide the container access to additional ComposablePartCatalog objects. |
Methods
| Compose(CompositionBatch) |
Adds or removes the parts in the specified CompositionBatch from the container and executes composition. |
| Dispose(Boolean) |
Releases the unmanaged resources used by the CompositionContainer and optionally releases the managed resources. |
| Dispose() |
Releases all resources used by the current instance of the CompositionContainer class. |
| GetExportsCore(ImportDefinition, AtomicComposition) |
Returns a collection of all exports that match the conditions in the specified ImportDefinition object. |
| ReleaseExport(Export) |
Releases the specified Export object from the CompositionContainer. |
| ReleaseExport<T>(Lazy<T>) |
Removes the specified export from composition and releases its resources if possible. |
| ReleaseExports(IEnumerable<Export>) |
Releases a set of Export objects from the CompositionContainer. |
| ReleaseExports<T,TMetadataView>(IEnumerable<Lazy<T,TMetadataView>>) |
Removes a collection of exports from composition and releases their resources if possible. |
| ReleaseExports<T>(IEnumerable<Lazy<T>>) |
Removes a collection of exports from composition and releases their resources if possible. |
| SatisfyImportsOnce(ComposablePart) |
Satisfies the imports of the specified ComposablePart object without registering it for recomposition. |