public void ScopingEndToEndWithCompositionService_MatchingCatalogsShouldSucceed() { var c = new TypeCatalog(typeof(ClassRoot), typeof(ClassA)); var sd = c.AsScope(c.AsScope()); var container = new CompositionContainer(sd, CompositionOptions.ExportCompositionService); var fromRoot = container.GetExportedValue <ClassRoot>(); var a1 = fromRoot.classA.CreateExport().Value; var a2 = fromRoot.classA.CreateExport().Value; fromRoot.localClassA.InstanceValue = 101; a1.InstanceValue = 202; a2.InstanceValue = 303; if (a1.InstanceValue == a2.InstanceValue) { throw new Exception("Incorrect sharing, a1 is shared with a2"); } var xroot = new ImportA(); var x1 = new ImportA(); var x2 = new ImportA(); fromRoot.localClassA.CompositionService.SatisfyImportsOnce(xroot); a1.CompositionService.SatisfyImportsOnce(x1); a2.CompositionService.SatisfyImportsOnce(x2); Assert.AreEqual(xroot.classA.InstanceValue, fromRoot.localClassA.InstanceValue); Assert.AreEqual(x1.classA.InstanceValue, a1.InstanceValue); Assert.AreEqual(x2.classA.InstanceValue, a2.InstanceValue); }
public void SimpleChainWithTwoChildren() { var parentCatalog = new TypeCatalog(typeof(BarWithMany)); var childCatalog1 = new TypeCatalog(typeof(FooImpl)); var childCatalog2 = new TypeCatalog(typeof(Foo2Impl)); var scope = parentCatalog.AsScope(childCatalog1.AsScope(), childCatalog2.AsScope()); var container = new CompositionContainer(scope); var bar = container.GetExportedValue <IBarContract>() as BarWithMany; Assert.NotNull(bar); Assert.Equal(2, bar.FooFactories.Length); IFooContract foo1 = null; using (var efFoo1 = bar.FooFactories[0].CreateExport()) { foo1 = efFoo1.Value; } IFooContract foo2 = null; using (var efFoo2 = bar.FooFactories[1].CreateExport()) { foo2 = efFoo2.Value; } Assert.True(((foo1 is FooImpl) && (foo2 is Foo2Impl)) || ((foo2 is FooImpl) && (foo1 is Foo2Impl))); }
public void ExportFactoryCausesRejectionBasedOnCardinality() { var parentCatalog = new TypeCatalog(typeof(BarImpl)); var childCatalog = new TypeCatalog(typeof(FooImpl), typeof(Foo2Impl)); var scope = parentCatalog.AsScope(childCatalog.AsScope()); var container = new CompositionContainer(scope); var bar = container.GetExportedValueOrDefault <IBarContract>(); Assert.Null(bar); }
public void SimpleChainWithLowerLoopRejection() { var parentCatalog = new TypeCatalog(typeof(BarImpl)); var childCatalog = new TypeCatalog(typeof(Foo3Impl)); var scope = parentCatalog.AsScope(childCatalog.AsScope()); var container = new CompositionContainer(scope); var bar = container.GetExportedValueOrDefault <IBarContract>(); Assert.Null(bar); }
public void DontExportICompositionServiceFromChildImportShouldShouldThrowCompositionException() { var rootCatalog = new TypeCatalog(typeof(FromRoot)); var childCatalog = new TypeCatalog(typeof(ClassRequiresICompositionService), typeof(ClassOptionallyImportsICompositionService)); var scope = rootCatalog.AsScope(childCatalog.AsScope()); var container = new CompositionContainer(scope); ExceptionAssert.Throws <ImportCardinalityMismatchException>(() => { var fromRoot = container.GetExportedValue <FromRoot>(); Assert.IsNull(fromRoot); }); }
public void SelfExportFromExportFactory_ShouldSucceed() { var cat1 = new TypeCatalog(typeof(ClassRoot)); var cat2 = new TypeCatalog(typeof(ClassA), typeof(ClassB), typeof(ClassC), typeof(ClassD)); var sd = cat1.AsScope(cat2.AsScope()); var container = new CompositionContainer(sd); var fromRoot = container.GetExportedValue <ClassRoot>(); var a1 = fromRoot.classA.CreateExport().Value; a1.InstanceValue = 8; Assert.Equal(8, a1.classB.classA.InstanceValue); Assert.Equal(8, a1.classC.classA.InstanceValue); Assert.Equal(8, a1.classD.classA.InstanceValue); }
public void FilteredScopeFactoryOfTM_ShouldSucceed() { var c1 = new TypeCatalog(typeof(ClassRoot), typeof(ClassA)); var c2 = new TypeCatalog(typeof(ClassA), typeof(ClassB), typeof(ClassC)); var c3 = new TypeCatalog(typeof(ClassA), typeof(ClassB), typeof(ClassC)); var c4 = new TypeCatalog(typeof(ClassA), typeof(ClassB), typeof(ClassC)); var sd = c1.AsScope(c2.AsScopeWithPublicSurface <ClassA>(), c3.AsScopeWithPublicSurface <ClassB>(), c4.AsScopeWithPublicSurface <ClassC>()); var container = new CompositionContainer(sd); var fromRoot = container.GetExportedValue <ClassRoot>(); var a = fromRoot.classA.CreateExport().Value; var b = fromRoot.classB.CreateExport().Value; var c = fromRoot.classC.CreateExport().Value; }
public void ExportICompositionServiceFromChildImportShouldShouldSucceed() { var childCatalog = new TypeCatalog(typeof(ClassRequiresICompositionService), typeof(ClassOptionallyImportsICompositionService)); var rootCatalog = new TypeCatalog(typeof(FromRoot)); CompositionScopeDefinition scope = rootCatalog.AsScope(childCatalog.AsScope()); var container = new CompositionContainer(scope, CompositionOptions.ExportCompositionService); FromRoot fromRoot = container.GetExportedValue <FromRoot>(); ExportLifetimeContext <ClassRequiresICompositionService> requiredService = fromRoot.Required.CreateExport(); Assert.NotNull(requiredService.Value.CompositionService); ExportLifetimeContext <ClassOptionallyImportsICompositionService> optionalService = fromRoot.Optional.CreateExport(); Assert.NotNull(optionalService.Value.CompositionService); }
public void DeeplyNestedCatalogOverlappedCatalog_ShouldWork() { var cat1 = new TypeCatalog(typeof(ClassRoot), typeof(ClassA), typeof(ClassB), typeof(ClassC), typeof(ClassD)); var cat2 = cat1; var cat3 = cat1; var cat4 = cat1; var cat5 = cat1; var sd = cat1.AsScope(cat2.AsScope(cat3.AsScope(cat4.AsScope(cat5.AsScope())))); var container = new CompositionContainer(sd); var fromRoot = container.GetExportedValue <ClassRoot>(); var a1 = fromRoot.classA.CreateExport().Value; var b1 = a1.classB.CreateExport().Value; var c1 = b1.classC.CreateExport().Value; var d1 = c1.classD.CreateExport().Value; }
public void ScopeBridgingAdaptersImportExportProperty_ShouldSucceed() { var cat1 = new TypeCatalog(typeof(ClassRoot), typeof(ClassXXXX)); var cat2 = new TypeCatalog(typeof(ClassC), typeof(ClassD)); var sd = cat1.AsScope(cat2.AsScope()); var container = new CompositionContainer(sd); var fromRoot = container.GetExportedValue <ClassRoot>(); var c1 = fromRoot.classC.CreateExport().Value; var c2 = fromRoot.classC.CreateExport().Value; var c3 = fromRoot.classC.CreateExport().Value; var c4 = fromRoot.classC.CreateExport().Value; var c5 = fromRoot.classC.CreateExport().Value; Assert.Equal(0, fromRoot.xxxx.InstanceValue); Assert.Equal(0, c1.xxxx.InstanceValue); Assert.Equal(0, c1.classD.xxxx.InstanceValue); Assert.Equal(0, c2.xxxx.InstanceValue); Assert.Equal(0, c2.classD.xxxx.InstanceValue); Assert.Equal(0, c3.xxxx.InstanceValue); Assert.Equal(0, c3.classD.xxxx.InstanceValue); Assert.Equal(0, c4.xxxx.InstanceValue); Assert.Equal(0, c4.classD.xxxx.InstanceValue); Assert.Equal(0, c5.xxxx.InstanceValue); Assert.Equal(0, c5.classD.xxxx.InstanceValue); c1.xxxx.InstanceValue = 1; c2.xxxx.InstanceValue = 2; c3.xxxx.InstanceValue = 3; c4.xxxx.InstanceValue = 4; c5.xxxx.InstanceValue = 5; Assert.Equal(0, fromRoot.xxxx.InstanceValue); Assert.Equal(1, c1.xxxx.InstanceValue); Assert.Equal(1, c1.classD.xxxx.InstanceValue); Assert.Equal(2, c2.xxxx.InstanceValue); Assert.Equal(2, c2.classD.xxxx.InstanceValue); Assert.Equal(3, c3.xxxx.InstanceValue); Assert.Equal(3, c3.classD.xxxx.InstanceValue); Assert.Equal(4, c4.xxxx.InstanceValue); Assert.Equal(4, c4.classD.xxxx.InstanceValue); Assert.Equal(5, c5.xxxx.InstanceValue); Assert.Equal(5, c5.classD.xxxx.InstanceValue); }
public void ExportICompositionServiceFromChildImportShouldShouldSucceed() { var childCatalog = new TypeCatalog(typeof(ClassRequiresICompositionService), typeof(ClassOptionallyImportsICompositionService)); var rootCatalog = new TypeCatalog(typeof(FromRoot)); var scope = rootCatalog.AsScope(childCatalog.AsScope()); var container = new CompositionContainer(scope, CompositionOptions.ExportCompositionService); var fromRoot = container.GetExportedValue <FromRoot>(); var requiredService = fromRoot.Required.CreateExport(); Console.WriteLine("requiredService: {0}", requiredService.Value.CompositionService); Assert.IsNotNull(requiredService.Value.CompositionService); var optionalService = fromRoot.Optional.CreateExport(); Console.WriteLine("optionalService: {0}", optionalService.Value.CompositionService); Assert.IsNotNull(optionalService.Value.CompositionService); }
public void FilteredScopeFactoryOfT_ShouldSucceed() { var c1 = new TypeCatalog(typeof(ClassRoot), typeof(ClassA)); var c2 = new TypeCatalog(typeof(ClassA), typeof(ClassB), typeof(ClassC), typeof(ClassD)); var sd = c1.AsScope(c2.AsScope()); var container = new CompositionContainer(sd); var fromRoot = container.GetExportedValue <ClassRoot>(); fromRoot.classA.ValueToFilter = "IncludeInFirstInstance"; var a1 = fromRoot.classA.CreateExport().Value; fromRoot.classA.ValueToFilter = "IncludeInSubsequentInstances"; var a2 = fromRoot.classA.CreateExport().Value; Assert.AreEqual(fromRoot.localClassA.filteredTypes.Count(), 0); Assert.AreEqual(a1.filteredTypes.Count(), 2); Assert.AreEqual(a2.filteredTypes.Count(), 1); }
public void ScopeFactoryAutoResolveFromAncestorScopeShouldSucceed() { var c1 = new TypeCatalog(typeof(ClassRoot), typeof(ClassA), typeof(Root)); var c2 = new TypeCatalog(typeof(ClassRoot), typeof(ClassA), typeof(Child)); var sd = c1.AsScope(c2.AsScope()); var container = new CompositionContainer(sd, CompositionOptions.ExportCompositionService); var fromRoot = container.GetExportedValue <ClassRoot>(); var a1 = fromRoot.classA.CreateExport().Value; var a2 = fromRoot.classA.CreateExport().Value; fromRoot.localClassA.InstanceValue = 101; a1.InstanceValue = 202; a2.InstanceValue = 303; Assert.NotEqual(a1.InstanceValue, a2.InstanceValue); Assert.NotNull(fromRoot.localClassA.classRoot); Assert.NotNull(a1.classRoot); Assert.NotNull(a2.classRoot); }
public void LocalSharedNonLocalInSameContainer_ShouldSucceed() { var cat1 = new TypeCatalog(typeof(ClassRoot), typeof(ClassXXXX)); var cat2 = new TypeCatalog(typeof(ClassA)); var cat3 = new TypeCatalog(typeof(ClassB)); var cat4 = new TypeCatalog(typeof(ClassC), typeof(ClassD), typeof(ClassXXXX)); var sd = cat1.AsScope(cat2.AsScope(cat3.AsScope(cat4.AsScope()))); var container = new CompositionContainer(sd); var fromRoot = container.GetExportedValue <ClassRoot>(); var a1 = fromRoot.classA.CreateExport().Value; fromRoot.xxxx.InstanceValue = 16; var b1 = a1.classB.CreateExport().Value; var c1 = b1.classC.CreateExport().Value; Assert.Equal(16, fromRoot.xxxx.InstanceValue); Assert.Equal(16, a1.xxxx.InstanceValue); Assert.Equal(16, b1.xxxx.InstanceValue); Assert.Equal(16, c1.xxxx.InstanceValue); Assert.Equal(0, c1.classD.xxxx.InstanceValue); c1.xxxx.InstanceValue = 8; Assert.Equal(8, fromRoot.xxxx.InstanceValue); Assert.Equal(8, a1.xxxx.InstanceValue); Assert.Equal(8, b1.xxxx.InstanceValue); Assert.Equal(8, c1.xxxx.InstanceValue); Assert.Equal(0, c1.classD.xxxx.InstanceValue); c1.classD.xxxx.InstanceValue = 2; Assert.Equal(8, fromRoot.xxxx.InstanceValue); Assert.Equal(8, a1.xxxx.InstanceValue); Assert.Equal(8, b1.xxxx.InstanceValue); Assert.Equal(8, c1.xxxx.InstanceValue); Assert.Equal(2, c1.classD.xxxx.InstanceValue); }
public void SimpleChainWithCrossLoop() { var parentCatalog = new TypeCatalog(typeof(BarImpl)); var childCatalog = new TypeCatalog(typeof(Foo4Impl)); var scope = parentCatalog.AsScope(childCatalog.AsScope()); var container = new CompositionContainer(scope); var bar = container.GetExportedValue <IBarContract>(); Assert.NotNull(bar); var foo1 = bar.CreateFoo(); Assert.NotNull(foo1); Assert.True(foo1 is Foo4Impl); var foo2 = bar.CreateFoo(); Assert.NotNull(foo1); Assert.True(foo2 is Foo4Impl); Assert.NotEqual(foo1, foo2); }