CompositionContainer Classe

Définition

Espace de noms:

System.ComponentModel.Composition.Hosting

Assembly:

System.ComponentModel.Composition.dll

Paquet:

System.ComponentModel.Composition v11.0.0-preview.2.26159.112

Source:

CompositionContainer.cs

Gère la composition des parties.

public ref class CompositionContainer : System::ComponentModel::Composition::Hosting::ExportProvider, IDisposable, System::ComponentModel::Composition::ICompositionService

public class CompositionContainer : System.ComponentModel.Composition.Hosting.ExportProvider, IDisposable, System.ComponentModel.Composition.ICompositionService

type CompositionContainer = class
    inherit ExportProvider
    interface ICompositionService
    interface IDisposable

Public Class CompositionContainer
Inherits ExportProvider
Implements ICompositionService, IDisposable

Héritage

Object

ExportProvider

CompositionContainer

Implémente

ICompositionService IDisposable

Exemples

Dans l’exemple suivant, un CompositionContainer objet est initialisé avec un catalogue et est utilisé pour remplir les importations d’un composant. Cet exemple utilise le modèle de programmation attributs.

[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

Remarques

Un CompositionContainer objet sert deux objectifs majeurs dans une application. Tout d’abord, il effectue le suivi des parties disponibles pour la composition et de leurs dépendances, et effectue la composition chaque fois que l’ensemble des parties disponibles change. Ensuite, il fournit les méthodes par lesquelles l’application obtient des instances de parties composées ou remplit les dépendances d’une partie composable.

Important

Ce type implémente l’interface IDisposable . Une fois que vous avez fini d’utiliser le type, vous devez le supprimer directement ou indirectement. Pour supprimer directement le type, appelez sa Dispose méthode dans un try/catch bloc. Pour la supprimer indirectement, utilisez une construction de langage telle que using (en C#) ou Using (en Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet implémentant IDisposable » dans la rubrique d’interface IDisposable .

Les parties peuvent être mises à la disposition du conteneur directement ou via la Catalog propriété. Toutes les parties détectables dans ce ComposablePartCatalog conteneur sont disponibles pour remplir les importations, ainsi que toutes les parties ajoutées directement.

La Compose méthode permet d’ajouter des parties instanciées à un conteneur existant. En supposant que la composition réussit, ces parties auront leurs importations remplies de pièces récupérées à partir du conteneur, et leurs exportations seront disponibles pour d’autres parties. Les importations marquées comme recomposables seront enregistrées pour la recomposition.

La SatisfyImportsOnce méthode permet à une partie d’avoir ses importations remplies sans être ajoutées au conteneur. Si la composition réussit, les importations du composant seront remplies, mais les exportations du composant ne seront pas disponibles pour d’autres parties et aucune importation n’est enregistrée pour la recomposition.

CompositionContainer les objets doivent toujours être supprimés. Lorsque la Dispose méthode est appelée, l’objet CompositionContainer supprime également toutes les parties qu’il a créées.

Un CompositionContainer objet accessible à partir de plusieurs threads doit être construit avec le isThreadSafe paramètre défini sur true, à l’aide du CompositionContainer(ComposablePartCatalog, Boolean, ExportProvider[]) constructeur. Les performances seront légèrement plus lentes lorsque isThreadSafe c’est truele cas. Nous vous recommandons donc de définir ce paramètre false dans les scénarios à thread unique. La valeur par défaut est false.

Avertissement

Un CompositionContainer ne doit jamais s’importer lui-même, ou une partie qui a une référence à celle-ci. Une telle référence peut permettre à une partie non approuvée d’accéder à toutes les parties du conteneur.

Constructeurs

Nom	Description
CompositionContainer()	Initialise une nouvelle instance de la classe CompositionContainer.
CompositionContainer(ComposablePartCatalog, Boolean, ExportProvider[])	Initialise une nouvelle instance de la CompositionContainer classe avec le catalogue, le mode thread-safe et les fournisseurs d’exportation spécifiés.
CompositionContainer(ComposablePartCatalog, CompositionOptions, ExportProvider[])	Initialise une nouvelle instance de la CompositionContainer classe avec le catalogue, les options et les fournisseurs d’exportation spécifiés.
CompositionContainer(ComposablePartCatalog, ExportProvider[])	Initialise une nouvelle instance de la CompositionContainer classe avec le catalogue et les fournisseurs d’exportation spécifiés.
CompositionContainer(CompositionOptions, ExportProvider[])	Initialise une nouvelle instance de la CompositionContainer classe avec les fournisseurs et options d’exportation spécifiés.
CompositionContainer(ExportProvider[])	Initialise une nouvelle instance de la CompositionContainer classe avec les fournisseurs d’exportation spécifiés.

Propriétés

Nom	Description
Catalog	Obtient le ComposablePartCatalog conteneur qui fournit l’accès au conteneur aux Export objets.
Providers	Obtient les fournisseurs d’exportation qui fournissent l’accès au conteneur à des objets supplémentaires ComposablePartCatalog .

Méthodes

Nom	Description
Compose(CompositionBatch)	Ajoute ou supprime les parties dans le conteneur spécifié CompositionBatch et exécute la composition.
Dispose()	Libère toutes les ressources utilisées par l’instance actuelle de la CompositionContainer classe.
Dispose(Boolean)	Libère les ressources non managées utilisées par les CompositionContainer ressources gérées et libère éventuellement les ressources managées.
GetExport<T,TMetadataView>()	Retourne l’exportation avec le nom de contrat dérivé du paramètre de type spécifié. S’il n’existe pas exactement une exportation correspondante, une exception est levée. (Hérité de ExportProvider)
GetExport<T,TMetadataView>(String)	Retourne l’exportation avec le nom de contrat spécifié. S’il n’existe pas exactement une exportation correspondante, une exception est levée. (Hérité de ExportProvider)
GetExport<T>()	Retourne l’exportation avec le nom de contrat dérivé du paramètre de type spécifié. S’il n’existe pas exactement une exportation correspondante, une exception est levée. (Hérité de ExportProvider)
GetExport<T>(String)	Retourne l’exportation avec le nom de contrat spécifié. S’il n’existe pas exactement une exportation correspondante, une exception est levée. (Hérité de ExportProvider)
GetExportedValue<T>()	Retourne l’objet exporté avec le nom de contrat dérivé du paramètre de type spécifié. S’il n’existe pas exactement un objet exporté correspondant, une exception est levée. (Hérité de ExportProvider)
GetExportedValue<T>(String)	Retourne l’objet exporté avec le nom de contrat spécifié. S’il n’existe pas exactement un objet exporté correspondant, une exception est levée. (Hérité de ExportProvider)
GetExportedValueOrDefault<T>()	Obtient l’objet exporté avec le nom de contrat dérivé du paramètre de type spécifié ou la valeur par défaut du type spécifié, ou lève une exception s’il existe plusieurs objets exportés correspondants. (Hérité de ExportProvider)
GetExportedValueOrDefault<T>(String)	Obtient l’objet exporté avec le nom de contrat spécifié ou la valeur par défaut du type spécifié, ou lève une exception s’il existe plusieurs objets exportés correspondants. (Hérité de ExportProvider)
GetExportedValues<T>()	Obtient tous les objets exportés avec le nom de contrat dérivé du paramètre de type spécifié. (Hérité de ExportProvider)
GetExportedValues<T>(String)	Obtient tous les objets exportés avec le nom de contrat spécifié. (Hérité de ExportProvider)
GetExports(ImportDefinition, AtomicComposition)	Obtient toutes les exportations qui correspondent aux conditions de la définition et de la composition d’importation spécifiées. (Hérité de ExportProvider)
GetExports(ImportDefinition)	Obtient toutes les exportations qui correspondent aux conditions de la définition d’importation spécifiée. (Hérité de ExportProvider)
GetExports(Type, Type, String)	Obtient toutes les exportations avec le nom de contrat spécifié. (Hérité de ExportProvider)
GetExports<T,TMetadataView>()	Obtient toutes les exportations avec le nom de contrat dérivé du paramètre de type spécifié. (Hérité de ExportProvider)
GetExports<T,TMetadataView>(String)	Obtient toutes les exportations avec le nom de contrat spécifié. (Hérité de ExportProvider)
GetExports<T>()	Obtient toutes les exportations avec le nom de contrat dérivé du paramètre de type spécifié. (Hérité de ExportProvider)
GetExports<T>(String)	Obtient toutes les exportations avec le nom de contrat spécifié. (Hérité de ExportProvider)
GetExportsCore(ImportDefinition, AtomicComposition)	Retourne une collection de toutes les exportations qui correspondent aux conditions de l’objet spécifié ImportDefinition .
OnExportsChanged(ExportsChangeEventArgs)	Déclenche l’événement ExportsChanged. (Hérité de ExportProvider)
OnExportsChanging(ExportsChangeEventArgs)	Déclenche l’événement ExportsChanging. (Hérité de ExportProvider)
ReleaseExport(Export)	Libère l’objet spécifié Export de l’objet CompositionContainer.
ReleaseExport<T>(Lazy<T>)	Supprime l’exportation spécifiée de la composition et libère ses ressources si possible.
ReleaseExports(IEnumerable<Export>)	Libère un ensemble d’objets Export à partir du CompositionContainer.
ReleaseExports<T,TMetadataView>(IEnumerable<Lazy<T,TMetadataView>>)	Supprime une collection d’exportations de composition et libère leurs ressources si possible.
ReleaseExports<T>(IEnumerable<Lazy<T>>)	Supprime une collection d’exportations de composition et libère leurs ressources si possible.
SatisfyImportsOnce(ComposablePart)	Satisfait les importations de l’objet spécifié ComposablePart sans l’inscrire pour la recomposition.
TryGetExports(ImportDefinition, AtomicComposition, IEnumerable<Export>)	Obtient toutes les exportations qui correspondent aux conditions de l’importation spécifiée. (Hérité de ExportProvider)

Événements

Nom	Description
ExportsChanged	Se produit lorsque les exportations de la ExportProvider modification sont effectuées. (Hérité de ExportProvider)
ExportsChanging	Se produit lorsque les exportations fournies changent. (Hérité de ExportProvider)

Méthodes d’extension

Nom	Description
ComposeExportedValue<T>(CompositionContainer, String, T)	Crée une partie à partir de l’objet spécifié sous le nom de contrat spécifié et le compose dans le conteneur de composition spécifié.
ComposeExportedValue<T>(CompositionContainer, T)	Crée une partie à partir de la valeur spécifiée et la compose dans le conteneur de composition spécifié.
ComposeParts(CompositionContainer, Object[])	Crée des parties composables à partir d’un tableau d’objets attribués et les compose dans le conteneur de composition spécifié.
SatisfyImportsOnce(ICompositionService, Object, ReflectionContext)	Compose la partie spécifiée à l’aide du service de composition spécifié, avec recomposition désactivée et à l’aide du contexte de réflexion spécifié.
SatisfyImportsOnce(ICompositionService, Object)	Compose la partie spécifiée à l’aide du service de composition spécifié, avec la recomposition désactivée.

Voir aussi

• Vue d’ensemble du modèle de programmation attribué