Partager via


CompositionContainer Classe

Définition

Gère la composition des composants.

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
CompositionContainer
Implémente

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 par 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 principaux 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 Dispose, appelez sa méthode dans un bloc try/catch. Pour la supprimer indirectement, utilisez une construction de langage telle que using (dans C#) ou Using (dans Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet qui implémente IDisposable » dans la rubrique de l’interface IDisposable.

Les parties peuvent être mises à la disposition du conteneur directement ou par le biais de la Catalog propriété . Toutes les parties détectables dans ce ComposablePartCatalog sont disponibles pour le conteneur pour répondre aux 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 est réussie, ces parties auront leurs importations remplies avec des parties 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 à un composant d’avoir ses importations remplies sans être ajoutées au conteneur. Si la composition réussit, les importations de la partie seront remplies, mais les exportations de la partie ne seront pas disponibles pour les autres parties et aucune importation ne sera 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 , à truel’aide du CompositionContainer(ComposablePartCatalog, Boolean, ExportProvider[]) constructeur . Les performances étant légèrement plus lentes lorsque isThreadSafe est true, nous vous recommandons de définir ce paramètre sur 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 à celui-ci. Une telle référence peut permettre à une partie non approuvée d’accéder à toutes les parties du conteneur.

Constructeurs

CompositionContainer()

Initialise une nouvelle instance de la classe CompositionContainer.

CompositionContainer(ComposablePartCatalog, Boolean, ExportProvider[])

Initialise une nouvelle instance de la classe CompositionContainer avec le catalogue spécifié, le mode thread-safe et les fournisseurs d'exportations.

CompositionContainer(ComposablePartCatalog, CompositionOptions, ExportProvider[])

Initialise une nouvelle instance de la classe CompositionContainer avec les catalogues, les options et les fournisseurs d'exportations spécifiés.

CompositionContainer(ComposablePartCatalog, ExportProvider[])

Initialise une nouvelle instance de la classe CompositionContainer avec les catalogues spécifiés et les fournisseurs d'exportations.

CompositionContainer(CompositionOptions, ExportProvider[])

Initialise une nouvelle instance de la classe CompositionContainer avec les fournisseurs d'exportations et les options spécifiés.

CompositionContainer(ExportProvider[])

Initialise une nouvelle instance de la classe CompositionContainer avec les fournisseurs d'exportations spécifiés.

Propriétés

Catalog

Obtient le ComposablePartCatalog qui fournit au conteneur l'accès aux objets Export.

Providers

Obtient les fournisseurs d'exportations qui fournissent au conteneur l'accès aux objets ComposablePartCatalog supplémentaires.

Méthodes

Compose(CompositionBatch)

Ajoute ou supprime les parties dans le CompositionBatch spécifié du conteneur et exécute la composition.

Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe CompositionContainer.

Dispose(Boolean)

Libère les ressources non managées utilisées par CompositionContainer et libère éventuellement les ressources managées.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
GetExport<T,TMetadataView>()

Retourne l'exportation avec le nom de contrat dérivé du paramètre de type spécifié. Si la mise en correspondance ne donne pas une et une seule exportation, une exception est levée.

(Hérité de ExportProvider)
GetExport<T,TMetadataView>(String)

Retourne l'exportation avec le nom de contrat spécifié. Si la mise en correspondance ne donne pas une et une seule exportation, 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é. Si la mise en correspondance ne donne pas une et une seule exportation, une exception est levée.

(Hérité de ExportProvider)
GetExport<T>(String)

Retourne l'exportation avec le nom de contrat spécifié. Si la mise en correspondance ne donne pas une et une seule exportation, 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é. Si la mise en correspondance ne donne pas uniquement un seul objet exporté, une exception est levée.

(Hérité de ExportProvider)
GetExportedValue<T>(String)

Retourne l'objet exporté avec le nom de contrat spécifié. Si la mise en correspondance ne donne pas uniquement un seul objet exporté, 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 encore lève une exception s'il existe plusieurs correspondances d'objets exportés.

(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 encore lève une exception s'il existe plusieurs correspondances d'objets exportés.

(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)

Obtient toutes les exportations qui correspondent aux conditions de la définition de l'importation spécifiée.

(Hérité de ExportProvider)
GetExports(ImportDefinition, AtomicComposition)

Obtient toutes les exportations qui correspondent aux conditions de la définition et de la composition de l'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 dans l'objet ImportDefinition spécifié.

GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
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 Export spécifié du 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 jeu d'objets Export du CompositionContainer.

ReleaseExports<T,TMetadataView>(IEnumerable<Lazy<T,TMetadataView>>)

Supprime une collection d'exportations de la composition et libère leurs ressources, si possible.

ReleaseExports<T>(IEnumerable<Lazy<T>>)

Supprime une collection d'exportations de la composition et libère leurs ressources, si possible.

SatisfyImportsOnce(ComposablePart)

Satisfait les importations de l'objet ComposablePart spécifié sans l'enregistrer en vue de la recomposition.

ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)
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

ExportsChanged

Se produit lors de la modification des exportations de ExportProvider.

(Hérité de ExportProvider)
ExportsChanging

Se produit lorsque les exportations fournies sont modifiées.

(Hérité de ExportProvider)

Méthodes d’extension

ComposeExportedValue<T>(CompositionContainer, T)

Crée un composant à partir de la valeur spécifiée et le compose dans le conteneur de composition spécifié.

ComposeExportedValue<T>(CompositionContainer, String, T)

Crée un composant à partir de l'objet spécifié sous le nom de contrat spécifié et le compose dans le conteneur de composition spécifié.

ComposeParts(CompositionContainer, Object[])

Crée des composants composables à partir d'un tableau d'objets avec attributs et les compose dans le conteneur de composition spécifié.

SatisfyImportsOnce(ICompositionService, Object)

Compose le composant spécifié à l'aide du service de composition spécifié, avec la recomposition désactivée.

SatisfyImportsOnce(ICompositionService, Object, ReflectionContext)

Constitue la partie spécifiée à l'aide du service spécifié de composition, avec la recomposition désactivée et à l'aide du contexte de réflexion spécifié.

S’applique à

Voir aussi