public void SingleContainerPartReplacement()
{
var container = ContainerFactory.Create();
var importPart = PartFactory.CreateImporter(true, "value1", "value2");
CompositionBatch batch = new CompositionBatch();
var export1Key = batch.AddExportedValue("value1", "Hello");
batch.AddExportedValue("value2", "World");
batch.AddPart(importPart);
container.Compose(batch);
Assert.AreEqual(2, importPart.ImportSatisfiedCount);
Assert.AreEqual("Hello", importPart.GetImport("value1"));
Assert.AreEqual("World", importPart.GetImport("value2"));
importPart.ResetImportSatisfiedCount();
batch = new CompositionBatch();
batch.RemovePart(export1Key);
batch.AddExportedValue("value1", "Goodbye");
container.Compose(batch);
Assert.AreEqual(1, importPart.ImportSatisfiedCount);
Assert.AreEqual("Goodbye", importPart.GetImport("value1"));
Assert.AreEqual("World", importPart.GetImport("value2"));
}
private static void ComposeBatchTwo(CompositionContainer container)
{
var batch = new CompositionBatch();
batch.RemovePart(a);
c = batch.AddPart(new PluginC());
batch.AddPart(logger);
container.Compose(batch);
}
public void BatchRemove_ShouldFireEvents()
{
var container = ContainerFactory.Create();
var batch = new CompositionBatch();
var exportPart = batch.AddExportedValue<object>("MyExport", new object());
container.Compose(batch);
var eventListener = new ExportProviderListener(container, container);
batch = new CompositionBatch();
batch.RemovePart(exportPart);
eventListener.VerifyCompose(batch);
}
public void AddRemovePart_NonSharedPart_ShouldCollectWholeObjectChain()
{
var container = GetContainer();
var exportedValue = new NonSharedImporter();
CompositionBatch batch = new CompositionBatch();
var part = batch.AddPart(exportedValue);
container.Compose(batch);
batch = null;
batch = new CompositionBatch();
batch.RemovePart(part);
container.Compose(batch);
batch = null;
var refTracker = new ReferenceTracker();
refTracker.AddReferencesExpectedToBeCollected(
exportedValue,
exportedValue.AnyPartDisposable,
exportedValue.AnyPartDisposableRecomposable,
exportedValue.AnyPartRecomposable,
exportedValue.AnyPartSimple);
part = null;
exportedValue = null;
refTracker.CollectAndAssert();
GC.KeepAlive(container);
}
public void ImportIntoUntypedExportTest()
{
var container = ContainerFactory.Create();
CompositionBatch batch = new CompositionBatch();
batch.AddExportedValue("untyped", 42);
var u = new UntypedExportImporter();
var rb = AttributedModelServices.CreatePart(u);
batch.AddPart(rb);
container.Compose(batch);
Assert.AreEqual(42, u.Export.Value);
var us = new UntypedExportsImporter();
batch = new CompositionBatch();
batch.AddExportedValue("untyped", 19);
batch.RemovePart(rb);
batch.AddPart(us);
container.Compose(batch);
Assert.IsNotNull(us.Exports, "Should have an enumeration");
Assert.AreEqual(2, us.Exports.Count(), "Should have 2 values");
}
public void ExportsChanged_ExportRemoved_ShouldFireExportsChanged()
{
var container = CreateCompositionContainer();
IEnumerable<string> changedNames = null;
CompositionBatch batch = new CompositionBatch();
var part = batch.AddExportedValue("MyExport", new object());
container.Compose(batch);
container.ExportsChanged += (sender, args) =>
{
Assert.AreSame(container, sender);
Assert.IsNull(changedNames, "Ensure this event only fires once!");
Assert.IsNotNull(args.AddedExports);
Assert.IsNotNull(args.RemovedExports);
Assert.IsNotNull(args.ChangedContractNames);
changedNames = args.ChangedContractNames;
};
batch = new CompositionBatch();
batch.RemovePart(part);
container.Compose(batch);
EnumerableAssert.AreEqual(changedNames, "MyExport");
}
public void ComposeDisposableChildContainer()
{
var outerContainer = CreateCompositionContainer();
Int32Importer outerImporter = new Int32Importer();
CompositionBatch outerBatch = new CompositionBatch();
var key = outerBatch.AddExportedValue("Value", 42);
outerBatch.AddPart(outerImporter);
outerContainer.Compose(outerBatch);
Assert.AreEqual(42, outerImporter.Value, "Expected value imported from export");
Int32Importer innerImporter = new Int32Importer();
var innerContainer = new CompositionContainer(outerContainer);
CompositionBatch innerBatch = new CompositionBatch();
innerBatch.AddPart(innerImporter);
innerContainer.Compose(innerBatch);
Assert.AreEqual(42, innerImporter.Value, "Expected value imported from export");
Assert.AreEqual(42, outerImporter.Value, "Expected value imported from export");
outerBatch = new CompositionBatch();
outerBatch.RemovePart(key);
key = outerBatch.AddExportedValue("Value", -5);
outerContainer.Compose(outerBatch);
Assert.AreEqual(-5, innerImporter.Value, "Expected update value imported from export");
Assert.AreEqual(-5, outerImporter.Value, "Expected updated value imported from export");
innerContainer.Dispose();
outerBatch = new CompositionBatch();
outerBatch.RemovePart(key);
key = outerBatch.AddExportedValue("Value", 500);
outerContainer.Compose(outerBatch);
Assert.AreEqual(500, outerImporter.Value, "Expected updated value imported from export");
Assert.AreEqual(-5, innerImporter.Value, "Expected value not updated");
}
public void RemovePart_PartInContainerQueueAsPartArgument_ShouldNotLeavePartInContainer()
{
const string contractName = "Contract";
var exporter = PartFactory.CreateExporter(new MicroExport(contractName, 1));
var importer = PartFactory.CreateImporter(contractName);
var container = ContainerFactory.Create(exporter, importer);
CompositionBatch batch = new CompositionBatch();
batch.RemovePart(exporter);
container.Compose(batch);
Assert.IsNull(importer.Value);
Assert.AreEqual(2, importer.ImportSatisfiedCount);
}
public void SharedPart_DisposableRecomposabeImport_ShouldNotBeCollected()
{
var catalog = new TypeCatalog(typeof(SharedPartDisposableRecomposable));
var container = new CompositionContainer(catalog);
// Setup dependency
CompositionBatch batch = new CompositionBatch();
var valueKey = batch.AddExportedValue("Value", 21);
container.Compose(batch);
batch = null;
var refTracker = new ReferenceTracker();
refTracker.AddReferencesNotExpectedToBeCollected(
container.GetExportedValue<SharedPartDisposableRecomposable>());
refTracker.CollectAndAssert();
// Lets make sure recomposition doesn't blow anything up here.
batch = new CompositionBatch();
batch.RemovePart(valueKey);
batch.AddExportedValue("Value", 42);
container.Compose(batch);
batch = null;
var exportedValue = (SharedPartDisposableRecomposable)refTracker.ReferencesNotExpectedToBeCollected[0].Target;
Assert.AreEqual(42, exportedValue.Value);
container.Dispose();
Assert.IsTrue(exportedValue.IsDisposed, "Any parts should be disposed with the container!");
}
public void AnyPart_RecomposabeImport_ShouldNotBeCollected()
{
var catalog = new TypeCatalog(typeof(AnyPartRecomposable));
var container = new CompositionContainer(catalog);
// Setup dependency
CompositionBatch batch = new CompositionBatch();
var valueKey = batch.AddExportedValue("Value", 21);
container.Compose(batch);
batch = null;
var refTracker = new ReferenceTracker();
refTracker.AddReferencesNotExpectedToBeCollected(
container.GetExportedValue<AnyPartRecomposable>());
refTracker.CollectAndAssert();
// Lets make sure recomposition doesn't blow anything up here.
batch = new CompositionBatch();
batch.RemovePart(valueKey);
batch.AddExportedValue("Value", 42);
container.Compose(batch);
batch = null;
var exportedValue = (AnyPartRecomposable)refTracker.ReferencesNotExpectedToBeCollected[0].Target;
Assert.AreEqual(42, exportedValue.Value);
GC.KeepAlive(container);
}
public void NonSharedPart_RecomposableImport_NoReference_ShouldBeCollected()
{
var catalog = new TypeCatalog(typeof(NonSharedPartRecomposable));
var container = new CompositionContainer(catalog);
// Setup dependency
CompositionBatch batch = new CompositionBatch();
var valueKey = batch.AddExportedValue("Value", 21);
container.Compose(batch);
batch = null;
var refTracker = new ReferenceTracker();
refTracker.AddReferencesExpectedToBeCollected(
container.GetExportedValue<NonSharedPartRecomposable>());
refTracker.CollectAndAssert();
// Recompose just to ensure we don't blow up, even though we don't expect anything to happen.
batch = new CompositionBatch();
batch.RemovePart(valueKey);
batch.AddExportedValue("Value", 42);
container.Compose(batch);
batch = null;
GC.KeepAlive(container);
}
/// <summary>
/// 卸载插件
/// </summary>
/// <param name="plugin"></param>
/// <returns></returns>
private bool UnLoadPlugin(IPlugin plugin)
{
bool isSuccess = false;
try
{
var batch = new CompositionBatch();
var part = AttributedModelServices.CreatePart(plugin);
//var part = batch.AddExportedValue<IPlugin>(plugin);
//var part2 = _container.GetExportedValues<IPlugin>().First();
//Lazy<IPlugin> part3 = _container.GetExport<IPlugin>();
//IPlugin tmp = part3.Value;
batch.RemovePart(part);
_container.Compose(batch);
//_container.ReleaseExport(part3);
isSuccess = true;
}
catch
{
isSuccess = false;
}
return isSuccess;
}
public void OptionalImportsOfExportReferenceTypesAreReboundToDefaultWhenExportIsRemoved()
{
var container = ContainerFactory.Create();
var importer = new OptionalExport();
CompositionBatch batch = new CompositionBatch();
batch.AddPart(importer);
var key = batch.AddExportedValue("ReferenceType", "Bar");
container.Compose(batch);
Assert.AreEqual(1, importer.ReferenceTypeSetCount);
Assert.AreEqual("Bar", importer.ReferenceType.Value);
batch = new CompositionBatch();
batch.RemovePart(key);
container.Compose(batch);
Assert.AreEqual(2, importer.ReferenceTypeSetCount);
Assert.IsNull(importer.ReferenceType);
}
public void OptionalImportsOfNullableValueTypesAreReboundToDefaultWhenExportIsRemoved()
{
var container = ContainerFactory.Create();
var importer = new OptionalImport();
CompositionBatch batch = new CompositionBatch();
batch.AddPart(importer);
var key = batch.AddExportedValue<int?>("NullableValueType", 10);
container.Compose(batch);
Assert.AreEqual(1, importer.NullableValueTypeSetCount);
Assert.AreEqual(10, importer.NullableValueType);
batch = new CompositionBatch();
batch.RemovePart(key);
container.Compose(batch);
Assert.AreEqual(2, importer.NullableValueTypeSetCount);
Assert.IsNull(importer.NullableValueType);
}
public void Rejection_DefendPromisesOnceMade()
{
var container = ContainerFactory.CreateWithAttributedCatalog(typeof(Needy));
var addBatch = new CompositionBatch();
var removeBatch = new CompositionBatch();
var addedPart = addBatch.AddPart(new NoImportPart());
removeBatch.RemovePart(addedPart);
// Add then remove should be fine as long as exports aren't used yet.
container.Compose(addBatch);
container.Compose(removeBatch);
// Add the dependencies
container.Compose(addBatch);
// Retrieve needy which uses an export from addedPart
var export = container.GetExportedValue<Needy>();
// Should not be able to remove the addedPart because someone depends on it.
ExceptionAssert.Throws<ChangeRejectedException>(() =>
container.Compose(removeBatch));
}
public void SelectiveRecompose()
{
var container = ContainerFactory.Create();
var stableImporter = PartFactory.CreateImporter("stable");
var dynamicImporter = PartFactory.CreateImporter("dynamic", true);
CompositionBatch batch = new CompositionBatch();
batch.AddPart(stableImporter);
batch.AddPart(dynamicImporter);
var exportKey = batch.AddExportedValue("dynamic", 1);
batch.AddExportedValue("stable", 42);
container.Compose(batch);
Assert.AreEqual(1, stableImporter.ImportSatisfiedCount);
Assert.AreEqual(stableImporter.GetImport("stable"), 42);
Assert.AreEqual(1, dynamicImporter.ImportSatisfiedCount);
Assert.AreEqual(dynamicImporter.GetImport("dynamic"), 1);
batch = new CompositionBatch();
stableImporter.ResetImportSatisfiedCount();
dynamicImporter.ResetImportSatisfiedCount();
batch.RemovePart(exportKey);
batch.AddExportedValue("dynamic", 2);
container.Compose(batch);
Assert.AreEqual(0, stableImporter.ImportSatisfiedCount, "Should not have imported the stable import part");
Assert.AreEqual(stableImporter.GetImport("stable"), 42);
Assert.AreEqual(1, dynamicImporter.ImportSatisfiedCount);
Assert.AreEqual(dynamicImporter.GetImport("dynamic"), 2);
}
public void NonSharedPart_RecomposableImport_WithReference_ShouldNotBeCollected()
{
var catalog = new TypeCatalog(typeof(NonSharedPartRecomposable));
var container = new CompositionContainer(catalog);
// Setup dependency
CompositionBatch batch = new CompositionBatch();
var valueKey = batch.AddExportedValue("Value", 21);
container.Compose(batch);
batch = null;
var exportedValue = container.GetExportedValue<NonSharedPartRecomposable>();
var refTracker = new ReferenceTracker();
refTracker.AddReferencesNotExpectedToBeCollected(exportedValue);
refTracker.CollectAndAssert();
// Recompose should work because we are still holding a reference to the exported value.
batch = new CompositionBatch();
batch.RemovePart(valueKey);
batch.AddExportedValue("Value", 42);
container.Compose(batch);
batch = null;
Assert.AreEqual(42, exportedValue.Value, "Value should have been recomposed");
GC.KeepAlive(container);
}
public void ParentedContainerPartReplacement()
{
var container = ContainerFactory.Create();
CompositionBatch batch = new CompositionBatch();
var importPart = PartFactory.CreateImporter(true, "value1", "value2");
var exportKey = batch.AddExportedValue("value1", "Parent");
var childContainer = new CompositionContainer(container);
CompositionBatch childBatch = new CompositionBatch();
childBatch.AddExportedValue("value2", "Child");
childBatch.AddPart(importPart);
Assert.AreEqual(0, importPart.ImportSatisfiedCount, "Should not import until outer scope is disposed");
container.Compose(batch);
childContainer.Compose(childBatch);
Assert.AreEqual(2, importPart.ImportSatisfiedCount);
Assert.AreEqual("Parent", importPart.GetImport("value1"));
Assert.AreEqual("Child", importPart.GetImport("value2"));
importPart.ResetImportSatisfiedCount();
batch = new CompositionBatch();
batch.RemovePart(exportKey);
batch.AddExportedValue("value1", "New Parent");
container.Compose(batch);
Assert.AreEqual(1, importPart.ImportSatisfiedCount);
Assert.AreEqual("New Parent", importPart.GetImport("value1"));
Assert.AreEqual("Child", importPart.GetImport("value2"));
}
public void NonSharedPart_DisposableRecomposabeImport_NoReference_ShouldNotBeCollected()
{
var catalog = new TypeCatalog(typeof(NonSharedPartDisposableRecomposable));
var container = new CompositionContainer(catalog);
// Setup dependency
CompositionBatch batch = new CompositionBatch();
var valueKey = batch.AddExportedValue("Value", 21);
container.Compose(batch);
batch = null;
var refTracker = new ReferenceTracker();
refTracker.AddReferencesNotExpectedToBeCollected(
container.GetExportedValue<NonSharedPartDisposableRecomposable>());
refTracker.CollectAndAssert();
// Recompose just to ensure we don't blow up, even though we don't expect anything to happen.
batch = new CompositionBatch();
batch.RemovePart(valueKey);
batch.AddExportedValue("Value", 42);
container.Compose(batch);
batch = null;
var exportedValue = (NonSharedPartDisposableRecomposable)refTracker.ReferencesNotExpectedToBeCollected[0].Target;
Assert.AreEqual(42, exportedValue.Value, "Value shoudl ahve been recomposed.");
GC.KeepAlive(container);
}
public void RemovePart_PartNotInContainerAsPartArgument_ShouldNotCauseImportsToBeRebound()
{
const string contractName = "Contract";
var exporter = PartFactory.CreateExporter(new MicroExport(contractName, 1));
var importer = PartFactory.CreateImporter(contractName);
var container = ContainerFactory.Create(exporter, importer);
Assert.AreEqual(1, importer.Value);
Assert.AreEqual(1, importer.ImportSatisfiedCount);
var doesNotExistInContainer = PartFactory.CreateExporter(new MicroExport(contractName, 2));
CompositionBatch batch = new CompositionBatch();
batch.RemovePart(doesNotExistInContainer);
container.Compose(batch);
Assert.AreEqual(1, importer.ImportSatisfiedCount);
}
public void AddRemovePart_SharedRoot_ShouldNotDisposeChain()
{
var container = GetContainer();
var exportedValue = new SharedImporter();
CompositionBatch batch = new CompositionBatch();
var part = batch.AddPart(exportedValue);
container.Compose(batch);
batch = new CompositionBatch();
batch.RemovePart(part);
container.Compose(batch);
Assert.IsFalse(exportedValue.AnyPartDisposable.IsDisposed);
Assert.IsFalse(exportedValue.AnyPartDisposableRecomposable.IsDisposed);
}
public void RemovePart_PartAlreadyRemovedAsPartArgument_ShouldNotThrow()
{
var exporter = PartFactory.CreateExporter(new MicroExport("Contract", 1));
var container = ContainerFactory.Create(exporter);
Assert.AreEqual(1, container.GetExportedValue<int>("Contract"));
CompositionBatch batch = new CompositionBatch();
batch.RemovePart(exporter);
container.Compose(batch);
Assert.IsFalse(container.IsPresent("Contract"));
batch = new CompositionBatch();
batch.RemovePart(exporter);
container.Compose(batch);
Assert.IsFalse(container.IsPresent("Contract"));
}
public void GetReleaseExport_NonSharedPart_ShouldNotRecomposeAfterRelease()
{
var catalog = new TypeCatalog(typeof(NonSharedPartRecomposable));
var container = new CompositionContainer(catalog);
// Setup dependency
CompositionBatch batch = new CompositionBatch();
var valueKey = batch.AddExportedValue("Value", 21);
container.Compose(batch);
var export = container.GetExport<NonSharedPartRecomposable>();
var exportedValue = export.Value;
Assert.AreEqual(21, exportedValue.Value);
container.ReleaseExport(export);
// Recompose just to ensure we don't blow up, even though we don't expect anything to happen.
batch = new CompositionBatch();
batch.RemovePart(valueKey);
batch.AddExportedValue("Value", 42);
container.Compose(batch);
Assert.AreEqual(21, exportedValue.Value, "Value should not be recomposed after ReleaseExport is called on it.");
}
public void RemoveValueTest()
{
var container = CreateCompositionContainer();
CompositionBatch batch = new CompositionBatch();
var key = batch.AddExportedValue("foo", "hello");
container.Compose(batch);
var result = container.GetExportedValue<string>("foo");
Assert.AreEqual("hello", result, "Should get the correct value");
batch = new CompositionBatch();
batch.RemovePart(key);
container.Compose(batch);
Assert.IsFalse(container.IsPresent("foo"));
batch = new CompositionBatch();
batch.RemovePart(key); // Remove should be idempotent
container.Compose(batch);
}
public void GetExportManualDisposeThenRecompose_NonSharedDisposableRecomposablePart_ShouldThrowComposition()
{
var catalog = new TypeCatalog(typeof(NonSharedPartDisposableRecomposable));
var container = new CompositionContainer(catalog);
// Setup dependency
CompositionBatch batch = new CompositionBatch();
var valueKey = batch.AddExportedValue("Value", 21);
container.Compose(batch);
var export = container.GetExport<NonSharedPartDisposableRecomposable>();
var exportedValue = export.Value;
Assert.AreEqual(21, exportedValue.Value);
exportedValue.Dispose();
// Recompose should cause a ObjectDisposedException.
batch = new CompositionBatch();
batch.RemovePart(valueKey);
batch.AddExportedValue("Value", 42);
CompositionAssert.ThrowsError(
ErrorId.ImportEngine_PartCannotActivate, // Cannot activate part because
ErrorId.ReflectionModel_ImportThrewException, // Import threw an exception
RetryMode.DoNotRetry,
() =>
{
container.Compose(batch);
});
}
public void RemoveFromWrongContainerTest()
{
CompositionContainer d1 = CreateCompositionContainer();
CompositionContainer d2 = CreateCompositionContainer();
CompositionBatch batch1 = new CompositionBatch();
var valueKey = batch1.AddExportedValue("a", 1);
d1.Compose(batch1);
CompositionBatch batch2 = new CompositionBatch();
batch2.RemovePart(valueKey);
// removing entry from wrong container, shoudl be a no-op
d2.Compose(batch2);
}
public void ChildContainerAddRemovePart_NonSharedRoot_ShouldDisposeChain()
{
var child = CreateParentChildContainerWithNonSharedImporter();
var exportedValue = new NonSharedImporter();
CompositionBatch batch = new CompositionBatch();
var part = batch.AddPart(exportedValue);
child.Compose(batch);
batch = new CompositionBatch();
batch.RemovePart(part);
child.Compose(batch);
Assert.IsTrue(exportedValue.AnyPartDisposable.IsDisposed);
Assert.IsTrue(exportedValue.AnyPartDisposableRecomposable.IsDisposed);
}
