System.ComponentModel.Composition 4.0.0.0 System.ComponentModel.Composition.Hosting.ExportProvider System.ComponentModel.Composition.ICompositionService System.IDisposable A 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. Parts can be made available to the container either directly or through the property. All the parts discoverable in this are available to the container to fulfill imports, along with any parts added directly. The 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 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. objects should always be disposed. When the method is called, the object also disposes all the parts that it has created. A object that can be accessed from multiple threads must be constructed with the parameter set to true, using the constructor. Performance will be slightly slower when is true, so we recommend that you set this parameter to false in single-threaded scenarios. The default is false. A 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.

Manages the composition of parts.

Constructor 4.0.0.0 To be added.

Initializes a new instance of the class.

Constructor 4.0.0.0 System.ParamArray To be added.

Initializes a new instance of the class with the specified export providers.

An array of objects that provide the access to objects, or null to set to an empty . Constructor 4.0.0.0 System.ParamArray To be added.

Initializes a new instance of the class with the specified export providers and options.

An object that specifies the behavior of this container. An array of objects that provide the access to objects, or null to set to an empty . Constructor 4.0.0.0 System.ParamArray To be added.

Initializes a new instance of the class with the specified catalog and export providers.

A catalog that provides objects to the . An array of objects that provide the access to objects, or null to set to an empty . Constructor 4.0.0.0 System.ParamArray A object that can be accessed from multiple threads must set the parameter to true. Performance will be slightly slower when is true, so we recommend that you set this parameter to false in single-threaded scenarios. The default is false.

Initializes a new instance of the class with the specified catalog, thread-safe mode, and export providers.

A catalog that provides objects to the . true if this object must be thread-safe; otherwise, false. An array of objects that provide the access to objects, or null to set the property to an empty . Constructor 4.0.0.0 System.ParamArray To be added.

Initializes a new instance of the class with the specified catalog, options, and export providers.

A catalog that provides objects to the . An object that specifies options that affect the behavior of the container. An array of objects that provide the access to objects, or null to set to an empty . Property 4.0.0.0 System.ComponentModel.Composition.Primitives.ComposablePartCatalog To be added. To be added.

Gets the that provides the container access to objects.

Method 4.0.0.0 System.Void This method is the primary way of directly adding or removing parts from the container. The will always maintain a stable, composed state. Therefore, calling with an empty is never necessary to start composition. Instead, call the method whenever you need to make changes to the parts available to the . The can contain both parts to be added and parts to be removed. Recomposition will take place only once for each call to .

Adds or removes the parts in the specified from the container and executes composition.

Changes to the to include during the composition. Method 4.0.0.0 System.Void Call Dispose when you are finished using the . The Dispose method leaves the in an unusable state. After calling Dispose, you must release all references to the so the garbage collector can reclaim the memory that the was occupying. For more information, see Cleaning Up Unmanaged Resources and Implementing a Dispose Method. Always call Dispose before you release your last reference to the . Otherwise, the resources it is using will not be freed until the garbage collector calls the object's Finalize method.

Releases all resources used by the current instance of the class.

Method 4.0.0.0 System.Void To be added.

Releases the unmanaged resources used by the and optionally releases the managed resources.

true to release both managed and unmanaged resources; false to release only unmanaged resources. Method 4.0.0.0 System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.Export> Implementations should not treat cardinality-related mismatches as errors and should not throw exceptions for cardinality-related mismatches. For example, if the import requests exactly one export and the provider has either no matching exports or more than one, the method should return an empty collection of objects.

Returns a collection of all exports that match the conditions in the specified object.

A collection of all the objects in this object that match the conditions specified by . The object that defines the conditions of the objects to get. The composition transaction to use, or null to disable transactional composition. Property 4.0.0.0 System.Collections.ObjectModel.ReadOnlyCollection<System.ComponentModel.Composition.Hosting.ExportProvider> To be added. To be added.

Gets the export providers that provide the container access to additional objects.

Method 4.0.0.0 System.Void The behavior of this method may vary depending on the implementation of the that produced the instance. As a rule, non-shared exports should be detached from the container. For example, the will only release an if it comes from a that was constructed under a context. Release in this context means walking the dependency chain of the objects, detaching references from the container and calling Dispose on the objects as needed. If the was constructed under a context the will do nothing, as the specified may being used by other requestors. Those will only be detached when the container is itself disposed.

Releases the specified object from the .

The that needs to be released. Method 4.0.0.0 System.Void To be added.

Removes the specified export from composition and releases its resources if possible.

An indirect reference to the export to remove. The type of the export. Method 4.0.0.0 System.Void The behavior of this method may vary depending on the context in which the was constructed. For more information, see the method.

Releases a set of objects from the .

A collection of objects to be released. Method 4.0.0.0 System.Void To be added.

Removes a collection of exports from composition and releases their resources if possible.

A collection of indirect references to the exports to be removed. The type of the exports. Method 4.0.0.0 System.Void To be added. To be added. To be added.

To be added.

To be added. Method 4.0.0.0 System.Void To be added.

Satisfies the imports of the specified object without registering it for recomposition.

The part to satisfy the imports of.