CompositionContainer Classe

Definizione

Spazio dei nomi:

System.ComponentModel.Composition.Hosting

Assembly:

System.ComponentModel.Composition.dll

Pacchetto:

System.ComponentModel.Composition v8.0.0

Origine:

CompositionContainer.cs

Gestisce la composizione di parti.

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

Ereditarietà

Object

ExportProvider

CompositionContainer

Implementazioni

ICompositionService IDisposable

Esempio

Nell'esempio seguente un CompositionContainer oggetto viene inizializzato con un catalogo e viene usato per riempire le importazioni di una parte. In questo esempio viene usato il modello di programmazione con attributi.

[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

Commenti

Un CompositionContainer oggetto svolge due scopi principali in un'applicazione. In primo luogo, tiene traccia delle parti disponibili per la composizione e delle relative dipendenze ed esegue la composizione ogni volta che cambia il set di parti disponibili. In secondo luogo, fornisce i metodi in base ai quali l'applicazione ottiene istanze di parti composte o riempie le dipendenze di una parte componibile.

Importante

Il tipo implementa l'interfaccia IDisposable. Dopo aver utilizzato il tipo, è necessario eliminarlo direttamente o indirettamente. Per eliminare direttamente il tipo, chiamare il metodo Dispose in un blocco try/catch. Per eliminarlo indirettamente, utilizzare un costrutto di linguaggio come ad esempio using in C# o Using in Visual Basic. Per altre informazioni, vedere la sezione "Uso di un oggetto che implementa IDisposable" nell'argomento relativo all'interfaccia IDisposable.

Le parti possono essere rese disponibili per il contenitore direttamente o tramite la Catalog proprietà . Tutte le parti individuabili in questo ComposablePartCatalog sono disponibili per il contenitore per soddisfare le importazioni, insieme a tutte le parti aggiunte direttamente.

Il Compose metodo consente di aggiungere parti di cui è stata creata un'istanza a un contenitore esistente. Supponendo che la composizione abbia esito positivo, queste parti avranno le loro importazioni piene di parti recuperate dal contenitore e le relative esportazioni saranno disponibili per altre parti. Le importazioni contrassegnate come ricomponibili verranno registrate per la ricomposizione.

Il SatisfyImportsOnce metodo consente a una parte di riempirne le importazioni senza essere aggiunte al contenitore. Se la composizione ha esito positivo, le importazioni della parte verranno riempite, ma le esportazioni della parte non saranno disponibili in altre parti e nessuna importazione verrà registrata per la ricomposizione.

CompositionContainer gli oggetti devono essere sempre eliminati. Quando viene chiamato il Dispose metodo , l'oggetto CompositionContainer elimina anche tutte le parti create.

Un CompositionContainer oggetto a cui è possibile accedere da più thread deve essere costruito con il isThreadSafe parametro impostato su true, usando il CompositionContainer(ComposablePartCatalog, Boolean, ExportProvider[]) costruttore . Le prestazioni saranno leggermente più lente quando isThreadSafe è true, pertanto è consigliabile impostare questo parametro su false in scenari a thread singolo. Il valore predefinito è false.

Avviso

Un CompositionContainer oggetto non deve mai importare se stesso o una parte che contiene un riferimento. Un riferimento di questo tipo potrebbe consentire a una parte non attendibile di accedere a tutte le parti del contenitore.

Costruttori

CompositionContainer()	Inizializza una nuova istanza della classe CompositionContainer.
CompositionContainer(ComposablePartCatalog, Boolean, ExportProvider[])	Inizializza una nuova istanza della classe CompositionContainer con il catalogo, la modalità thread-safe e i provider di esportazione specificati.
CompositionContainer(ComposablePartCatalog, CompositionOptions, ExportProvider[])	Inizializza una nuova istanza della classe CompositionContainer con i provider di catalogo, opzioni e esportazione specificati.
CompositionContainer(ComposablePartCatalog, ExportProvider[])	Inizializza una nuova istanza della classe CompositionContainer con i provider di catalogo e di esportazione specificati.
CompositionContainer(CompositionOptions, ExportProvider[])	Inizializza una nuova istanza della classe CompositionContainer con i provider e le opzioni di esportazione specificati.
CompositionContainer(ExportProvider[])	Inizializza una nuova istanza della classe CompositionContainer con i provider di esportazione specificati.

Proprietà

Catalog	Ottiene l'oggetto ComposablePartCatalog che fornisce al contenitore l'accesso agli oggetti Export.
Providers	Ottiene i provider di esportazione che forniscono al contenitore l'accesso a oggetti ComposablePartCatalog aggiuntivi.

Metodi

Compose(CompositionBatch)	Aggiunge o rimuove le parti nell'oggetto CompositionBatch specificato dal contenitore ed esegue la composizione.
Dispose()	Rilascia tutte le risorse usate dall'istanza corrente della classe CompositionContainer.
Dispose(Boolean)	Rilascia le risorse non gestite usate da CompositionContainer e, facoltativamente, le risorse gestite.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetExport<T,TMetadataView>()	Restituisce l'esportazione con il nome di contratto derivato dal parametro di tipo specificato. Se non è presente esattamente un'esportazione corrispondente, viene generata un'eccezione. (Ereditato da ExportProvider)
GetExport<T,TMetadataView>(String)	Restituisce l'esportazione con il nome di contratto specificato. Se non è presente esattamente un'esportazione corrispondente, viene generata un'eccezione. (Ereditato da ExportProvider)
GetExport<T>()	Restituisce l'esportazione con il nome di contratto derivato dal parametro di tipo specificato. Se non è presente esattamente un'esportazione corrispondente, viene generata un'eccezione. (Ereditato da ExportProvider)
GetExport<T>(String)	Restituisce l'esportazione con il nome di contratto specificato. Se non è presente esattamente un'esportazione corrispondente, viene generata un'eccezione. (Ereditato da ExportProvider)
GetExportedValue<T>()	Restituisce l'oggetto esportato con il nome di contratto derivato dal parametro di tipo specificato. Se non è presente esattamente un oggetto esportato corrispondente, viene generata un'eccezione. (Ereditato da ExportProvider)
GetExportedValue<T>(String)	Restituisce l'oggetto esportato con il nome di contratto specificato. Se non è presente esattamente un oggetto esportato corrispondente, viene generata un'eccezione. (Ereditato da ExportProvider)
GetExportedValueOrDefault<T>()	Ottiene l'oggetto esportato con il nome di contratto derivato dal parametro di tipo specificato o il valore predefinito per il tipo specificato oppure genera un'eccezione se è presente più di un oggetto esportato corrispondente. (Ereditato da ExportProvider)
GetExportedValueOrDefault<T>(String)	Ottiene l'oggetto esportato con il nome di contratto specificato o il valore predefinito per il tipo specificato oppure genera un'eccezione se è presente più di un oggetto esportato corrispondente. (Ereditato da ExportProvider)
GetExportedValues<T>()	Ottiene tutti gli oggetti esportati con il nome di contratto derivato dal parametro di tipo specificato. (Ereditato da ExportProvider)
GetExportedValues<T>(String)	Ottiene tutti gli oggetti esportati con il nome di contratto specificato. (Ereditato da ExportProvider)
GetExports(ImportDefinition)	Ottiene tutte le esportazioni che corrispondono alle condizioni della definizione dell'importazione specificata. (Ereditato da ExportProvider)
GetExports(ImportDefinition, AtomicComposition)	Ottiene tutte le esportazioni che corrispondono alle condizioni della definizione e della composizione dell'importazione specificate. (Ereditato da ExportProvider)
GetExports(Type, Type, String)	Ottiene tutte le esportazioni con il nome di contratto specificato. (Ereditato da ExportProvider)
GetExports<T,TMetadataView>()	Ottiene tutte le esportazioni con il nome di contratto derivato dal parametro di tipo specificato. (Ereditato da ExportProvider)
GetExports<T,TMetadataView>(String)	Ottiene tutte le esportazioni con il nome di contratto specificato. (Ereditato da ExportProvider)
GetExports<T>()	Ottiene tutte le esportazioni con il nome di contratto derivato dal parametro di tipo specificato. (Ereditato da ExportProvider)
GetExports<T>(String)	Ottiene tutte le esportazioni con il nome di contratto specificato. (Ereditato da ExportProvider)
GetExportsCore(ImportDefinition, AtomicComposition)	Restituisce una raccolta di tutte le esportazioni che corrispondono alle condizioni nell'oggetto ImportDefinition specificato.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
OnExportsChanged(ExportsChangeEventArgs)	Genera l'evento ExportsChanged. (Ereditato da ExportProvider)
OnExportsChanging(ExportsChangeEventArgs)	Genera l'evento ExportsChanging. (Ereditato da ExportProvider)
ReleaseExport(Export)	Rilascia l'oggetto Export specificato dall'oggetto CompositionContainer.
ReleaseExport<T>(Lazy<T>)	Rimuove l'esportazione specificata dalla composizione e rilascia le relative risorse se possibile.
ReleaseExports(IEnumerable<Export>)	Rilascia un set di oggetti Export dall'oggetto CompositionContainer.
ReleaseExports<T,TMetadataView>(IEnumerable<Lazy<T,TMetadataView>>)	Rimuove una raccolta di esportazioni dalla composizione e rilascia le relative risorse se possibile.
ReleaseExports<T>(IEnumerable<Lazy<T>>)	Rimuove una raccolta di esportazioni dalla composizione e rilascia le relative risorse se possibile.
SatisfyImportsOnce(ComposablePart)	Soddisfa le importazioni dell'oggetto ComposablePart specificato senza registrarlo per la ricomposizione.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
TryGetExports(ImportDefinition, AtomicComposition, IEnumerable<Export>)	Ottiene tutte le esportazioni che corrispondono alle condizioni dell'importazione specificata. (Ereditato da ExportProvider)

Eventi

ExportsChanged	Si verifica quando le esportazioni nell'oggetto ExportProvider vengono modificate. (Ereditato da ExportProvider)
ExportsChanging	Si verifica quando vengono modificate le esportazioni fornite. (Ereditato da ExportProvider)

Metodi di estensione

ComposeExportedValue<T>(CompositionContainer, T)	Crea una parte dal valore specificato e la compone nel contenitore di composizione specificato.
ComposeExportedValue<T>(CompositionContainer, String, T)	Crea una parte dall'oggetto specificato sotto il nome del contratto specificato e la compone nel contenitore di composizione specificato.
ComposeParts(CompositionContainer, Object[])	Crea parti componibili da una matrice di oggetti con attributi e le compone nel contenitore di composizione specificato.
SatisfyImportsOnce(ICompositionService, Object)	Compone la parte specificata, utilizzando il servizio di composizione specificato, con la ricomposizione disabilitata.
SatisfyImportsOnce(ICompositionService, Object, ReflectionContext)	Compone la parte specificata, utilizzando il servizio di composizione specificato, con la ricomposizione disabilitata e utilizzando il contesto di reflection specificato.

Vedi anche

• Cenni preliminari sul modello di programmazione con attributi