CompositionContainer Classe

Definição

Namespace:

System.ComponentModel.Composition.Hosting

Assembly:

System.ComponentModel.Composition.dll

Pacote:

System.ComponentModel.Composition v8.0.0

Source:

CompositionContainer.cs

Gerencia a composição de partes.

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

Herança

Object

ExportProvider

CompositionContainer

Implementações

ICompositionService IDisposable

Exemplos

No exemplo a seguir, um CompositionContainer objeto é inicializado com um catálogo e é usado para preencher as importações de uma parte. Este exemplo usa o modelo de programação atribuída.

[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

Comentários

Um CompositionContainer objeto serve a duas finalidades principais em um aplicativo. Primeiro, ele controla quais partes estão disponíveis para composição e quais são suas dependências e executa a composição sempre que o conjunto de partes disponíveis é alterado. Em segundo lugar, ele fornece os métodos pelos quais o aplicativo obtém instâncias de partes compostas ou preenche as dependências de uma parte composável.

Importante

Esse tipo implementa a interface IDisposable. Quando você terminar de usar o tipo, deverá descartá-lo direta ou indiretamente. Para descartar o tipo diretamente, chame o método Dispose dele em um bloco try/catch. Para descartá-lo indiretamente, use um constructo de linguagem como using ( em C#) ou Using (em Visual Basic). Saiba mais na seção "Como usar um objeto que implementa IDisposable" no tópico da interface IDisposable.

As partes podem ser disponibilizadas para o contêiner diretamente ou por meio da Catalog propriedade . Todas as partes detectáveis nesse ComposablePartCatalog contêiner estão disponíveis para atender às importações, juntamente com todas as partes adicionadas diretamente.

O Compose método permite que partes instanciadas sejam adicionadas a um contêiner existente. Supondo que a composição seja bem-sucedida, essas partes terão suas importações preenchidas com partes recuperadas do contêiner e suas exportações estarão disponíveis para outras partes. As importações marcadas como recomposíveis serão registradas para recomposição.

O SatisfyImportsOnce método permite que uma parte tenha suas importações preenchidas sem ser adicionada ao contêiner. Se a composição for bem-sucedida, as importações da parte serão preenchidas, mas as exportações da parte não estarão disponíveis para outras partes e nenhuma importação será registrada para recomposição.

CompositionContainer os objetos sempre devem ser descartados. Quando o Dispose método é chamado, o CompositionContainer objeto também descarta todas as partes que ele criou.

Um CompositionContainer objeto que pode ser acessado de vários threads deve ser construído com o isThreadSafe parâmetro definido como true, usando o CompositionContainer(ComposablePartCatalog, Boolean, ExportProvider[]) construtor . O desempenho será um pouco mais lento quando isThreadSafe for true, portanto, recomendamos que você defina esse parâmetro como false em cenários de thread único. O padrão é false.

Aviso

Um CompositionContainer nunca deve importar a si mesmo ou uma parte que tenha uma referência a ela. Essa referência pode permitir que uma parte não confiável obtenha acesso a todas as partes no contêiner.

Construtores

CompositionContainer()	Inicializa uma nova instância da classe CompositionContainer.
CompositionContainer(ComposablePartCatalog, Boolean, ExportProvider[])	Inicializa uma nova instância da classe CompositionContainer com o catálogo, modo thread-safe e provedores de exportação especificados.
CompositionContainer(ComposablePartCatalog, CompositionOptions, ExportProvider[])	Inicializa uma nova instância da classe CompositionContainer com os provedores de exportação, de opções e de catálogo especificados.
CompositionContainer(ComposablePartCatalog, ExportProvider[])	Inicializa uma nova instância da classe CompositionContainer com os provedores de exportação e de catálogo especificados.
CompositionContainer(CompositionOptions, ExportProvider[])	Inicializa uma nova instância da classe CompositionContainer com as opções e os provedores de exportação especificados.
CompositionContainer(ExportProvider[])	Inicializa uma nova instância da classe CompositionContainer com os provedores de exportação especificados.

Propriedades

Catalog	Obtém o ComposablePartCatalog que fornece ao contêiner acesso a objetos Export.
Providers	Obtém os provedores de exportação que fornecem ao contêiner acesso a objetos ComposablePartCatalog adicionais.

Métodos

Compose(CompositionBatch)	Adiciona ou remove as partes no CompositionBatch especificado do contêiner e executa a composição.
Dispose()	Libera todos os recursos usados pela instância atual da classe CompositionContainer.
Dispose(Boolean)	Libera os recursos não gerenciados usados pelo CompositionContainer e opcionalmente libera os recursos gerenciados.
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetExport<T,TMetadataView>()	Retorna a exportação com o nome do contrato derivado do parâmetro de tipo especificado. Caso não haja exatamente uma exportação correspondente, uma exceção é lançada. (Herdado de ExportProvider)
GetExport<T,TMetadataView>(String)	Retorna a exportação com o nome do contrato especificado. Caso não haja exatamente uma exportação correspondente, uma exceção é lançada. (Herdado de ExportProvider)
GetExport<T>()	Retorna a exportação com o nome do contrato derivado do parâmetro de tipo especificado. Caso não haja exatamente uma exportação correspondente, uma exceção é lançada. (Herdado de ExportProvider)
GetExport<T>(String)	Retorna a exportação com o nome do contrato especificado. Caso não haja exatamente uma exportação correspondente, uma exceção é lançada. (Herdado de ExportProvider)
GetExportedValue<T>()	Retorna o objeto exportado com o nome do contrato derivado do parâmetro de tipo especificado. Se não houver exatamente um objeto exportado correspondente, uma exceção será gerada. (Herdado de ExportProvider)
GetExportedValue<T>(String)	Retorna o objeto exportado com o nome do contrato especificado. Se não houver exatamente um objeto exportado correspondente, uma exceção será gerada. (Herdado de ExportProvider)
GetExportedValueOrDefault<T>()	Obtém o objeto exportado com o nome do contrato derivado do parâmetro de tipo especificado ou o valor padrão para o tipo especificado ou gera uma exceção, se houver mais de um objeto exportado correspondente. (Herdado de ExportProvider)
GetExportedValueOrDefault<T>(String)	Obtém o objeto exportado com o nome do contrato especificado ou o valor padrão para o tipo especificado ou gera uma exceção, se houver mais de um objeto exportado correspondente. (Herdado de ExportProvider)
GetExportedValues<T>()	Obtém todos os objetos exportados com o nome do contrato derivado do parâmetro de tipo especificado. (Herdado de ExportProvider)
GetExportedValues<T>(String)	Obtém os objetos exportados com o nome do contrato especificado. (Herdado de ExportProvider)
GetExports(ImportDefinition)	Obtém todas as exportações que correspondem às condições da definição de importação especificada. (Herdado de ExportProvider)
GetExports(ImportDefinition, AtomicComposition)	Obtém todas as exportações que correspondem às condições da definição e composição de importação especificadas. (Herdado de ExportProvider)
GetExports(Type, Type, String)	Obtém todas as exportações com o nome do contrato especificado. (Herdado de ExportProvider)
GetExports<T,TMetadataView>()	Obtém todas as exportações com o nome do contrato derivado do parâmetro de tipo especificado. (Herdado de ExportProvider)
GetExports<T,TMetadataView>(String)	Obtém todas as exportações com o nome do contrato especificado. (Herdado de ExportProvider)
GetExports<T>()	Obtém todas as exportações com o nome do contrato derivado do parâmetro de tipo especificado. (Herdado de ExportProvider)
GetExports<T>(String)	Obtém todas as exportações com o nome do contrato especificado. (Herdado de ExportProvider)
GetExportsCore(ImportDefinition, AtomicComposition)	Retorna uma coleção de todas as exportações que correspondem às condições no objeto ImportDefinition especificado.
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
OnExportsChanged(ExportsChangeEventArgs)	Aciona o evento ExportsChanged. (Herdado de ExportProvider)
OnExportsChanging(ExportsChangeEventArgs)	Aciona o evento ExportsChanging. (Herdado de ExportProvider)
ReleaseExport(Export)	Libera o objeto Export especificado do CompositionContainer.
ReleaseExport<T>(Lazy<T>)	Remove a exportação especificada de composição e libera seus recursos, se possível.
ReleaseExports(IEnumerable<Export>)	Libera um conjunto de objetos Export do CompositionContainer.
ReleaseExports<T,TMetadataView>(IEnumerable<Lazy<T,TMetadataView>>)	Remove uma coleção de exportações da composição e libera seus recursos, se possível.
ReleaseExports<T>(IEnumerable<Lazy<T>>)	Remove uma coleção de exportações da composição e libera seus recursos, se possível.
SatisfyImportsOnce(ComposablePart)	Satisfaz as importações do objeto ComposablePart especificado sem registrá-lo para recomposição.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)
TryGetExports(ImportDefinition, AtomicComposition, IEnumerable<Export>)	Obtém todas as exportações que correspondem às condições da importação especificada. (Herdado de ExportProvider)

Eventos

ExportsChanged	Ocorre quando as exportações no ExportProvider são alteradas. (Herdado de ExportProvider)
ExportsChanging	Ocorre quando as exportações fornecidas são alteradas. (Herdado de ExportProvider)

Métodos de Extensão

ComposeExportedValue<T>(CompositionContainer, T)	Cria uma parte do valor especificado e a combina no contêiner de combinação especificado.
ComposeExportedValue<T>(CompositionContainer, String, T)	Cria uma parte do objeto especificado sob o nome de contrato especificado e a compõe no contêiner de composição especificado.
ComposeParts(CompositionContainer, Object[])	Cria partes combináveis de uma matriz de objetos atribuídos e as combina no contêiner de combinação especificado.
SatisfyImportsOnce(ICompositionService, Object)	Compõe a parte especificada usando o serviço de composição especificado, com recomposição desabilitada.
SatisfyImportsOnce(ICompositionService, Object, ReflectionContext)	Compõe a parte especificada usando o serviço de composição especificado, com recomposição desabilitada e usando o contexto de reflexão especificado.

Confira também

• Visão geral do modelo de programação atribuído