/// <summary>
/// Initializes a new instance of the <see cref="CatalogExportProvider"/> class.
/// </summary>
/// <param name="catalog">
/// The <see cref="ComposablePartCatalog"/> that the <see cref="CatalogExportProvider"/>
/// uses to produce <see cref="Export"/> objects.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="catalog"/> is <see langword="null"/>.
/// </exception>
public CatalogExportProvider(ComposablePartCatalog catalog)
: this(catalog, CompositionOptions.Default)
{
}
public CatalogExportProvider(ComposablePartCatalog catalog, bool isThreadSafe)
: this(catalog, isThreadSafe ? CompositionOptions.IsThreadSafe : CompositionOptions.Default)
{
}
public AOPCompositionContainer(ComposablePartCatalog catalog, bool isThreadSafe, params ExportProvider[] providers)
: base(catalog, isThreadSafe, providers)
{
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (!_isDisposed)
{
//Note: We do not dispose _lock on dispose because DisposePart needs it to check isDisposed state
// to eliminate race conditions between it and Dispose
INotifyComposablePartCatalogChanged?catalogToUnsubscribeFrom = null;
HashSet <IDisposable>? partsToDispose = null;
ImportEngine? importEngine = null;
ExportProvider? sourceProvider = null;
AggregateExportProvider?aggregateExportProvider = null;
try
{
using (_lock.LockStateForWrite())
{
if (!_isDisposed)
{
catalogToUnsubscribeFrom = _catalog as INotifyComposablePartCatalogChanged;
_catalog = null !;
aggregateExportProvider = _innerExportProvider as AggregateExportProvider;
_innerExportProvider = null;
sourceProvider = _sourceProvider;
_sourceProvider = null;
importEngine = _importEngine;
_importEngine = null;
partsToDispose = _partsToDispose;
_gcRoots = null;
_isDisposed = true;
}
}
}
finally
{
if (catalogToUnsubscribeFrom != null)
{
catalogToUnsubscribeFrom.Changing -= OnCatalogChanging;
}
if (aggregateExportProvider != null)
{
aggregateExportProvider.Dispose();
}
if (sourceProvider != null)
{
sourceProvider.ExportsChanging -= OnExportsChangingInternal;
}
if (importEngine != null)
{
importEngine.Dispose();
}
if (partsToDispose != null)
{
foreach (var part in partsToDispose)
{
part.Dispose();
}
}
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CompositionContainer"/> class
/// with the specified catalog and export providers.
/// </summary>
/// <param name="providers">
/// A <see cref="Array"/> of <see cref="ExportProvider"/> objects which provide
/// the <see cref="CompositionContainer"/> access to <see cref="Export"/> objects,
/// or <see langword="null"/> to set <see cref="Providers"/> to an empty
/// <see cref="ReadOnlyCollection{T}"/>.
/// </param>
/// <exception cref="ArgumentException">
/// <paramref name="providers"/> contains an element that is <see langword="null"/>.
/// </exception>
public CompositionContainer(ComposablePartCatalog catalog, params ExportProvider[] providers) :
this(catalog, false, providers)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="CompositionContainer"/> class
/// with the specified catalog and export providers.
/// </summary>
/// <param name="compositionOptions">
/// <see cref="CompositionOptions"/> enumeration with flags controlling the composition.
/// </param>
/// <param name="providers">
/// A <see cref="Array"/> of <see cref="ExportProvider"/> objects which provide
/// the <see cref="CompositionContainer"/> access to <see cref="Export"/> objects,
/// or <see langword="null"/> to set <see cref="Providers"/> to an empty
/// <see cref="ReadOnlyCollection{T}"/>.
/// </param>
/// <exception cref="ArgumentException">
/// <paramref name="providers"/> contains an element that is <see langword="null"/>.
/// </exception>
public CompositionContainer(ComposablePartCatalog catalog, CompositionOptions compositionOptions, params ExportProvider[] providers)
{
if (compositionOptions > (CompositionOptions.DisableSilentRejection | CompositionOptions.IsThreadSafe | CompositionOptions.ExportCompositionService))
{
throw new ArgumentOutOfRangeException(nameof(compositionOptions));
}
_compositionOptions = compositionOptions;
// We always create the mutable provider
_partExportProvider = new ComposablePartExportProvider(compositionOptions);
_partExportProvider.SourceProvider = this;
// Create the catalog export provider, only if necessary
if (catalog != null)
{
_catalogExportProvider = new CatalogExportProvider(catalog, compositionOptions);
_catalogExportProvider.SourceProvider = this;
}
// Set the local export provider
if (_catalogExportProvider != null)
{
_localExportProvider = new AggregateExportProvider(_partExportProvider, _catalogExportProvider);
_disposableLocalExportProvider = _localExportProvider as IDisposable;
}
else
{
_localExportProvider = _partExportProvider;
}
// Set the ancestor export provider, if ancestors are supplied
if ((providers != null) && (providers.Length > 0))
{
// Aggregate ancestors if and only if more than one passed
if (providers.Length > 1)
{
_ancestorExportProvider = new AggregateExportProvider(providers);
_disposableAncestorExportProvider = _ancestorExportProvider as IDisposable;
}
else
{
if (providers[0] == null)
{
throw ExceptionBuilder.CreateContainsNullElement(nameof(providers));
}
_ancestorExportProvider = providers[0];
}
}
// finally set the root provider
if (_ancestorExportProvider == null)
{
// if no ancestors are passed, the local and the root are the same
_rootProvider = _localExportProvider;
}
else
{
int exportProviderCount = 1 + ((catalog != null) ? 1 : 0) + ((providers != null) ? providers.Length : 0);
ExportProvider[] rootProviders = new ExportProvider[exportProviderCount];
rootProviders[0] = _partExportProvider;
int customProviderStartIndex = 1;
if (catalog != null)
{
rootProviders[1] = _catalogExportProvider;
customProviderStartIndex = 2;
}
if (providers != null)
{
for (int i = 0; i < providers.Length; i++)
{
rootProviders[customProviderStartIndex + i] = providers[i];
}
}
_rootProvider = new AggregateExportProvider(rootProviders);
_disposableRootProvider = _rootProvider as IDisposable;
}
//Insert Composition Service
if (compositionOptions.HasFlag(CompositionOptions.ExportCompositionService))
{
this.ComposeExportedValue <ICompositionService>(new CompositionServiceShim(this));
}
_rootProvider.ExportsChanged += OnExportsChangedInternal;
_rootProvider.ExportsChanging += OnExportsChangingInternal;
_providers = (providers != null) ? new ReadOnlyCollection <ExportProvider>((ExportProvider[])providers.Clone()) : EmptyProviders;
}
/// <summary>
/// Initializes a new instance of the <see cref="CompositionContainer"/> class
/// with the specified catalog and export providers.
/// </summary>
/// <param name="isThreadSafe">
/// <see cref="bool"/> indicates whether container instances are threadsafe.
/// </param>
/// <param name="providers">
/// A <see cref="Array"/> of <see cref="ExportProvider"/> objects which provide
/// the <see cref="CompositionContainer"/> access to <see cref="Export"/> objects,
/// or <see langword="null"/> to set <see cref="Providers"/> to an empty
/// <see cref="ReadOnlyCollection{T}"/>.
/// </param>
/// <exception cref="ArgumentException">
/// <paramref name="providers"/> contains an element that is <see langword="null"/>.
/// </exception>
public CompositionContainer(ComposablePartCatalog catalog, bool isThreadSafe, params ExportProvider[] providers)
: this(catalog, isThreadSafe ? CompositionOptions.IsThreadSafe : CompositionOptions.Default, providers)
{
}
public CompositionContainer(ComposablePartCatalog catalog)
{
_catalog = catalog;
}
internal CompositionContainer CreateChildContainer(ComposablePartCatalog childCatalog)
{
return(new CompositionContainer(childCatalog, _catalogExportProvider._compositionOptions, _catalogExportProvider._sourceProvider !));
}
