private CatalogPart GetComposablePart(ComposablePartDefinition partDefinition, bool isSharedPart)
{
ThrowIfDisposed();
EnsureRunning();
CatalogPart catalogPart;
if (isSharedPart)
{
catalogPart = GetSharedPart(partDefinition);
}
else
{
ComposablePart part = partDefinition.CreatePart();
catalogPart = new CatalogPart(part);
if (part is IDisposable disposablePart)
{
using (_lock.LockStateForWrite())
{
_partsToDispose.Add(disposablePart);
}
}
}
return(catalogPart);
}
private void PreventPartCollection(object exportedValue, ComposablePart part)
{
ArgumentNullException.ThrowIfNull(exportedValue);
ArgumentNullException.ThrowIfNull(part);
using (_lock.LockStateForWrite())
{
List <ComposablePart>?partList;
ConditionalWeakTable <object, List <ComposablePart> >?gcRoots = _gcRoots;
gcRoots ??= new ConditionalWeakTable <object, List <ComposablePart> >();
if (!gcRoots.TryGetValue(exportedValue, out partList))
{
partList = new List <ComposablePart>();
gcRoots.Add(exportedValue, partList);
}
partList.Add(part);
if (_gcRoots == null)
{
Thread.MemoryBarrier();
_gcRoots = gcRoots;
}
}
}
public static CompositionError InvalidStateForRecompposition(ComposablePart part)
{
return(CompositionError.Create(
CompositionErrorId.ImportEngine_InvalidStateForRecomposition,
SR.ImportEngine_InvalidStateForRecomposition,
part.ToElement().DisplayName));
}
/// <summary>
/// Tries the satisfy imports.
/// </summary>
/// <param name="part">The part.</param>
public static void TrySatisfyImports(ComposablePart part)
{
if (part == null)
{
throw new ArgumentNullException("part");
}
CompositionBatch batch = new CompositionBatch();
batch.AddPart(part);
if (part.ExportDefinitions.Any())
{
return;
}
CompositionContainer container = GlobalContainer;
using (__lock.ForWrite())
{
try
{
container.Compose(batch);
}
catch {}
}
}
private ComposablePart GetSharedPart(ComposablePartDefinition partDefinition)
{
ComposablePart part;
bool found = false;
using (this._lock.LockStateForRead())
{
found = this._activatedParts.TryGetValue(partDefinition, out part);
}
if (!found)
{
ComposablePart newPart = partDefinition.CreatePart();
using (this._lock.LockStateForWrite())
{
found = this._activatedParts.TryGetValue(partDefinition, out part);
if (!found)
{
part = newPart;
this._activatedParts.Add(partDefinition, part);
IDisposable disposablePart = part as IDisposable;
if (disposablePart != null)
{
this._partsToDispose.Add(disposablePart);
}
}
}
}
return(part);
}
public void SatisfyImportsOnce(ComposablePart part)
{
if (this.ImportsSatisfied != null)
{
this.ImportsSatisfied.Invoke(this, new SatisfyImportsEventArgs(part));
}
}
public static CompositionError CreatePartCannotSetImport(ComposablePart part, ImportDefinition definition, Exception innerException)
{
if (part == null)
{
throw new ArgumentNullException(nameof(part));
}
if (definition == null)
{
throw new ArgumentNullException(nameof(definition));
}
if (innerException == null)
{
throw new ArgumentNullException(nameof(innerException));
}
ICompositionElement element = definition.ToElement();
return(CompositionError.Create(
CompositionErrorId.ImportEngine_PartCannotSetImport,
element,
innerException,
SR.ImportEngine_PartCannotSetImport,
element.DisplayName,
part.ToElement().DisplayName));
}
private CatalogPart GetComposablePart(ComposablePartDefinition partDefinition, bool isSharedPart)
{
this.ThrowIfDisposed();
this.EnsureRunning();
CatalogPart catalogPart = null;
if (isSharedPart)
{
catalogPart = this.GetSharedPart(partDefinition);
}
else
{
ComposablePart part = partDefinition.CreatePart();
catalogPart = new CatalogPart(part);
IDisposable disposablePart = part as IDisposable;
if (disposablePart != null)
{
using (this._lock.LockStateForWrite())
{
this._partsToDispose.Add(disposablePart);
}
}
}
return(catalogPart);
}
private void PreventPartCollection(object exportedValue, ComposablePart part)
{
Assumes.NotNull(exportedValue, part);
using (this._lock.LockStateForWrite())
{
List <ComposablePart> partList;
ConditionalWeakTable <object, List <ComposablePart> > gcRoots = this._gcRoots;
if (gcRoots == null)
{
gcRoots = new ConditionalWeakTable <object, List <ComposablePart> >();
}
if (!gcRoots.TryGetValue(exportedValue, out partList))
{
partList = new List <ComposablePart>();
gcRoots.Add(exportedValue, partList);
}
partList.Add(part);
if (this._gcRoots == null)
{
Thread.MemoryBarrier();
this._gcRoots = gcRoots;
}
}
}
public void SatisfyImportsOnce(ComposablePart part)
{
if (this.DoNothingOnSatisfyImportsOnce)
{
return;
}
CompositionBatch batch = new CompositionBatch();
// We only want to include the standard exports and parts to compose in the first composition
if (!this.alreadyComposed)
{
foreach (object instance in this.PartsToCompose)
{
batch.AddPart(instance);
}
foreach (Export export in this.ExportsToCompose)
{
batch.AddExport(export);
}
}
if (part != null)
{
batch.AddPart(part);
}
this.container.Compose(batch);
this.alreadyComposed = true;
}
private object GetExportedValue(ComposablePart part, ExportDefinition export)
{
this.ThrowIfDisposed();
this.EnsureRunning();
return(CompositionServices.GetExportedValueFromComposedPart(this._importEngine, part, export));
}
public static CompositionException CreateCannotGetExportedValue(ComposablePart part, ExportDefinition definition, Exception innerException)
{
Assumes.NotNull(part, definition, innerException);
return(new CompositionException(
ErrorBuilder.CreateCannotGetExportedValue(part, definition, innerException)));
}
public void PartsToAdd_ShouldGetCopiedAfterAdd()
{
CompositionBatch batch = new CompositionBatch();
ComposablePart part1 = PartFactory.Create();
ComposablePart part2 = PartFactory.Create();
batch.AddPart(part1);
Assert.Contains(part1, batch.PartsToAdd);
ReadOnlyCollection <ComposablePart> partsToAddBeforeCopy = batch.PartsToAdd;
Assert.Same(partsToAddBeforeCopy, batch.PartsToAdd);
Assert.Equal(1, partsToAddBeforeCopy.Count);
Assert.Contains(part1, partsToAddBeforeCopy);
batch.AddPart(part2);
ReadOnlyCollection <ComposablePart> partsToAddAfterCopy = batch.PartsToAdd;
Assert.Same(partsToAddAfterCopy, batch.PartsToAdd);
Assert.Equal(2, partsToAddAfterCopy.Count);
Assert.Contains(part1, partsToAddAfterCopy);
Assert.Contains(part2, partsToAddAfterCopy);
Assert.NotSame(partsToAddBeforeCopy, partsToAddAfterCopy);
}
public void PartsToRemove_ShouldGetCopiedAfterRemove()
{
CompositionBatch batch = new CompositionBatch();
ComposablePart part1 = PartFactory.Create();
ComposablePart part2 = PartFactory.Create();
batch.RemovePart(part1);
Assert.True(batch.PartsToRemove.Contains(part1));
ReadOnlyCollection <ComposablePart> partsToRemoveBeforeCopy = batch.PartsToRemove;
Assert.Same(partsToRemoveBeforeCopy, batch.PartsToRemove);
Assert.Equal(1, partsToRemoveBeforeCopy.Count);
Assert.True(partsToRemoveBeforeCopy.Contains(part1));
batch.RemovePart(part2);
ReadOnlyCollection <ComposablePart> partsToRemoveAfterCopy = batch.PartsToRemove;
Assert.Same(partsToRemoveAfterCopy, batch.PartsToRemove);
Assert.Equal(2, partsToRemoveAfterCopy.Count);
Assert.True(partsToRemoveAfterCopy.Contains(part1));
Assert.True(partsToRemoveAfterCopy.Contains(part2));
Assert.NotSame(partsToRemoveBeforeCopy, partsToRemoveAfterCopy);
}
private PartManager GetPartManager(ComposablePart part, bool createIfNotpresent)
{
PartManager partManager = null;
using (_lock.LockStateForRead())
{
if (_partManagers.TryGetValue(part, out partManager))
{
return(partManager);
}
}
if (createIfNotpresent)
{
using (_lock.LockStateForWrite())
{
if (!_partManagers.TryGetValue(part, out partManager))
{
partManager = new PartManager(this, part);
_partManagers.Add(part, partManager);
}
}
}
return(partManager);
}
public StatusBarProgressContext(
EventHandler <ProgressCompleteEventArgs> progressComplete,
ComposablePart statusItemPart)
{
ProgressComplete = progressComplete;
StatusItemPart = statusItemPart;
}
public static CompositionError PreventedByExistingImport(ComposablePart part, ImportDefinition import)
{
return(CompositionError.Create(
CompositionErrorId.ImportEngine_PreventedByExistingImport,
SR.ImportEngine_PreventedByExistingImport,
import.ToElement().DisplayName,
part.ToElement().DisplayName));
}
public void DerivedMetadataAttributeAttribute_ShouldSupplyMetadata()
{
ComposablePart part = AttributedModelServices.CreatePart(new ExportWithDerivedMetadataAttribute());
ExportDefinition export = part.ExportDefinitions.Single();
Assert.AreEqual("BaseValue", export.Metadata["BaseKey"]);
Assert.AreEqual("DerivedValue", export.Metadata["DerivedKey"]);
}
public static CompositionException CreateCannotGetExportedValue(ComposablePart part, ExportDefinition definition, Exception innerException)
{
ArgumentNullException.ThrowIfNull(part);
ArgumentNullException.ThrowIfNull(definition);
ArgumentNullException.ThrowIfNull(innerException);
return(new CompositionException(
ErrorBuilder.CreateCannotGetExportedValue(part, definition, innerException)));
}
/// <summary>
/// Removes a ComposablePart from the composition</summary>
/// <param name="composer">IComposer</param>
/// <param name="composablePart">ComposablePart to remove from the compositoi</param>
public static void RemovePart(this IComposer composer, ComposablePart composablePart)
{
Requires.NotNull(composer, "composer");
Requires.NotNull(composablePart, "composablePart");
var batch = new CompositionBatch(Enumerable.Empty <ComposablePart>(), new ComposablePart[] { composablePart });
composer.Container.Compose(batch);
}
public void Constructor2_PartsToRemoveAsNull_PartsToRemoveShouldBeEmpty()
{
ComposablePart[] partsToAdd = new ComposablePart[] { PartFactory.Create(), PartFactory.Create(), PartFactory.Create() };
var batch = new CompositionBatch(partsToAdd, null);
Assert.Equal(partsToAdd.Length, batch.PartsToAdd.Count);
Assert.Equal(0, batch.PartsToRemove.Count);
}
public void SatisfyImportsOnce(ComposablePart part)
{
Requires.NotNull(part, nameof(part));
if (_compositionContainer == null)
{
throw new Exception(SR.Diagnostic_InternalExceptionMessage);
}
_compositionContainer.SatisfyImportsOnce(part);
}
public void SatisfyImportsOnce(ComposablePart part)
{
var batch = new CompositionBatch();
batch.AddPart(part);
batch.AddExportedValue(Mock.Of <IVsSolutionManager>());
_container.Compose(batch);
}
protected override object GetExportedValueCore()
{
ComposablePart part = this._catalogExportProvider.GetComposablePart(this._partDefinition, this.IsSharedPart);
object exportedValue = this._catalogExportProvider.GetExportedValue(part, this._definition, this.IsSharedPart);
this._part = part;
return(exportedValue);
}
public static void Compose(ComposablePart o)
{
var container = new CompositionContainer(
new DirectoryCatalog(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "bin")));
var batch = new CompositionBatch();
batch.AddPart(o);
container.Compose(batch);
}
public void Constructor2_PartsToRemoveHasNull_ShouldThrowArgumentNullException()
{
ComposablePart[] partsToAdd = new ComposablePart[] { PartFactory.Create(), PartFactory.Create(), PartFactory.Create() };
ComposablePart[] partsToRemove = new ComposablePart[] { PartFactory.Create(), null, PartFactory.Create() };
Assert.Throws <ArgumentException>("partsToRemove", () =>
{
new CompositionBatch(partsToAdd, partsToRemove);
});
}
/// <summary>
/// Sets the imports of the specified composable part exactly once and they will not
/// ever be recomposed.
/// </summary>
/// <param name="part">
/// The <see cref="ComposablePart"/> to set the imports.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="part"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="CompositionException">
/// An error occurred during composition. <see cref="CompositionException.Errors"/> will
/// contain a collection of errors that occurred.
/// </exception>
/// <exception cref="ObjectDisposedException">
/// The <see cref="ICompositionService"/> has been disposed of.
/// </exception>
public void SatisfyImportsOnce(ComposablePart part)
{
this.ThrowIfDisposed();
Requires.NotNull(part, "part");
var result = TrySatisfyImports(part, false);
result.ThrowOnErrors(); // throw CompositionException not ChangeRejectedException
}
/// <summary>
/// Will satisfy the imports on a object instance based on a <see cref="CompositionContainer"/>
/// registered with the <see cref="CompositionHost"/>. By default if no <see cref="CompositionContainer"/>
/// is registered the first time this is called it will be initialized to a catalog
/// that contains all the assemblies loaded by the initial application XAP.
/// </summary>
/// <param name="attributedPart">
/// Object instance that contains <see cref="ImportAttribute"/>s that need to be satisfied.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="instance"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="ArgumentException">
/// <paramref name="instance"/> contains <see cref="ExportAttribute"/>s applied on its type.
/// </exception>
/// <exception cref="ChangeRejectedException">
/// One or more of the imports on the object instance could not be satisfied.
/// </exception>
/// <exception cref="CompositionException">
/// One or more of the imports on the object instance caused an error while composing.
/// </exception>
public static void SatisfyImports(object attributedPart)
{
if (attributedPart == null)
{
throw new ArgumentNullException("attributedPart");
}
ComposablePart part = AttributedModelServices.CreatePart(attributedPart);
CompositionInitializer.SatisfyImports(part);
}
public void SatisfyImportsOnce(ComposablePart part)
{
if (_imported)
{
return;
}
ThrowIfDisposed();
Container.SatisfyImportsOnce(part);
_imported = true;
}
private PartManager GetPartManager(ComposablePart part)
{
PartManager partManager = null;
if (!this._partManagers.TryGetValue(part, out partManager))
{
partManager = new PartManager(part);
this._partManagers.Add(part, partManager);
}
return(partManager);
}
