public void Implementation()
{
var types = new[] { typeof(Implemented) }.AsApplicationParts();
var container = new ContainerConfiguration().WithParts( types.AsEnumerable() ).WithProvider( SingletonExportDescriptorProvider.Default ).CreateContainer();
Assert.Same( Implemented.Default, container.GetExport<ISingleton>() );
Assert.Same( Implemented.Default, container.GetExport<Implemented>() );
}
public void Basic()
{
var types = new[] { typeof(Singleton) }.AsApplicationParts();
var container = new ContainerConfiguration().WithParts( types.AsEnumerable() ).WithProvider( SingletonExportDescriptorProvider.Default ).CreateContainer();
var export = container.GetExport<Singleton>();
Assert.Same( Singleton.Default, export );
}
public void ProvidersCanDetectAbsenceOfAContractItSupports()
{
var container = new ContainerConfiguration()
.WithProvider(new DefaultObjectExportDescriptorProvider())
.CreateContainer();
var o = container.GetExport<object>();
Assert.Equal(DefaultObjectExportDescriptorProvider.DefaultObject, o);
}
public void AConcreteTypeWithDictionaryConstructorIsAMetadataView()
{
var cc = new ContainerConfiguration()
.WithPart<HasNameA>()
.CreateContainer();
var hn = cc.GetExport<Lazy<HasNameA, DictionaryName>>();
Assert.Equal("A", hn.Metadata.RetrievedName);
}
public void MetadataViewsCanCarryDefaultValues()
{
var cc = new ContainerConfiguration()
.WithPart<HasNoName>()
.CreateContainer();
var hn = cc.GetExport<Lazy<HasNoName, OptionallyNamed>>();
Assert.Equal("B", hn.Metadata.Name);
}
public void AConcreteTypeWithWritablePropertiesIsAMetadataView()
{
var cc = new ContainerConfiguration()
.WithPart<HasNameA>()
.CreateContainer();
var hn = cc.GetExport<Lazy<HasNameA, Named>>();
Assert.Equal("A", hn.Metadata.Name);
}
public void AConcreteTypeWithUnsupportedConstructorsCannotBeUsedAsAMetadataView()
{
var cc = new ContainerConfiguration()
.WithPart<HasNameA>()
.CreateContainer();
var x = Assert.Throws<CompositionFailedException>(() => cc.GetExport<Lazy<HasNoName, InvalidConcreteView>>());
Assert.Equal("The type 'InvalidConcreteView' cannot be used as a metadata view. A metadata view must be a concrete class with a parameterless or dictionary constructor.", x.Message);
}
public void ProvidersCanLocateImplementationsOfAContractItSupports()
{
var container = new ContainerConfiguration()
.WithProvider(new DefaultObjectExportDescriptorProvider())
.WithPart<ExportsObject>()
.CreateContainer();
var o = container.GetExport<object>();
Assert.NotEqual(DefaultObjectExportDescriptorProvider.DefaultObject, o);
}
public override Action GetOperation()
{
var c = new ContainerConfiguration()
.WithPart(typeof(X))
.CreateContainer();
return () =>
{
c.GetExport<X>();
};
}
protected void Application_Start()
{
SetupAutoMapper();
var container = new ContainerConfiguration()
.WithAssembly(typeof(WebApiApplication).Assembly)
.CreateContainer();
var resolver = new StandaloneDependencyResolver(container);
GlobalConfiguration.Configuration.DependencyResolver = resolver;
GlobalConfiguration.Configure(container.GetExport<WebApiConfig>().Register);
}
public void Basic()
{
var parts = this.Adapt().WithNested().Append( typeof(Protected) ).AsApplicationParts();
var builder = ConventionBuilderFactory.Default.Get();
var container = new ContainerConfiguration().WithParts( parts.AsEnumerable(), builder ).WithProvider( ServicesExportDescriptorProvider.Default ).CreateContainer();
new EnableServicesCommand().Execute();
var dependency = container.GetExport<Dependency>();
Assert.NotNull( dependency );
var export = container.GetExport<IPrimary>();
var primary = Assert.IsType<Primary>( export );
Assert.Equal( 2, primary.Selected.GetParameters().Length );
var exported = container.GetExport<Exported>();
Assert.Equal( 3, exported.Selected.GetParameters().Length );
var external = container.GetExport<ExternalDependencyExport>();
Assert.Equal( 3, external.Selected.GetParameters().Length );
Assert.Throws<CompositionFailedException>( () => container.GetExport<Protected>() );
}
public void CreateContainer_ExportConventionsWithInheritedProperties_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType <DerivedFromBaseWithExport>()
.ExportProperty(b => b.Exported);
CompositionHost container = new ContainerConfiguration()
.WithDefaultConventions(conventions)
.WithParts(typeof(DerivedFromBaseWithExport))
.CreateContainer();
Assert.Equal("A", container.GetExport <string>());
}
public void NotifyImportsSatisfiedAttributeAlreadyApplied_ShouldSucceed()
{
var builder = new ConventionBuilder();
builder.ForType <OnImportsSatisfiedConfiguredClass>().NotifyImportsSatisfied(p => p.OnImportsSatisfied());
var container = new ContainerConfiguration()
.WithPart <OnImportsSatisfiedConfiguredClass>(builder)
.WithPart <ExportValues>(builder)
.CreateContainer();
var test = container.GetExport <OnImportsSatisfiedConfiguredClass>();
Assert.NotNull(test.P1);
Assert.NotNull(test.P2);
Assert.Equal(1, test.OnImportsSatisfiedInvoked);
}
public void NotifyImportsSatisfied_ShouldSucceed()
{
var builder = new ConventionBuilder();
builder.ForType <OnImportsSatisfiedTestClass>().NotifyImportsSatisfied(p => p.OnImportsSatisfied());
CompositionHost container = new ContainerConfiguration()
.WithPart <OnImportsSatisfiedTestClass>(builder)
.WithPart <ExportValues>(builder)
.CreateContainer();
OnImportsSatisfiedTestClass test = container.GetExport <OnImportsSatisfiedTestClass>();
Assert.NotNull(test.P1);
Assert.NotNull(test.P2);
Assert.Equal(1, test.OnImportsSatisfiedInvoked);
}
public override Action GetOperation()
{
var c = new ContainerConfiguration()
.WithPart(typeof(X))
.WithPart(typeof(XFactory))
.CreateContainer();
var xf = c.GetExport<XFactory>();
return () =>
{
var x = xf.CreateX();
var unused = x.Value;
x.Dispose();
};
}
public void NotifyImportsSatisfiedPropertiesAndFields_ShouldSucceed()
{
var builder = new ConventionBuilder();
builder.ForTypesMatching(t => true).NotifyImportsSatisfied(mi => mi.Name == "OnImportsSatisfied5" || mi.Name == "OnImportsSatisfied6");
var container = new ContainerConfiguration()
.WithPart <OnImportsSatisfiedTestClassPropertiesAndFields>(builder)
.WithPart <ExportValues>(builder)
.CreateContainer();
var test = container.GetExport <OnImportsSatisfiedTestClassPropertiesAndFields>();
Assert.NotNull(test.P1);
Assert.NotNull(test.P2);
Assert.Equal(0, test.OnImportsSatisfiedInvoked);
}
public void CreateContainer_OpenGenericTypes_Success()
{
var conventions = new ConventionBuilder();
conventions.ForTypesDerivedFrom <IContainer>()
.Export <IContainer>();
conventions.ForTypesDerivedFrom(typeof(IRepository <>))
.Export(t => t.AsContractType(typeof(IRepository <>)));
CompositionHost container = new ContainerConfiguration()
.WithParts(new Type[] { typeof(EFRepository <>), typeof(Container) }, conventions)
.CreateContainer();
Assert.Equal(0, container.GetExport <IRepository <int> >().Fetch());
}
public void NotifyImportsSatisfiedAttributeAppliedToBaseClass_ShouldSucceed()
{
var builder = new ConventionBuilder();
builder.ForTypesMatching(t => true).NotifyImportsSatisfied(mi => mi.Name == "OnImportsSatisfied");
var container = new ContainerConfiguration()
.WithPart <OnImportsSatisfiedDerivedClass>(builder)
.WithPart <ExportValues>(builder)
.CreateContainer();
var test = container.GetExport <OnImportsSatisfiedDerivedClass>();
Assert.NotNull(test.P1);
Assert.NotNull(test.P2);
Assert.Equal(1, test.OnImportsSatisfiedInvoked);
}
public void DictionaryImportsCompatibleWithConventionBuilder()
{
var rb = new ConventionBuilder();
rb.ForType <ConventionConsumer>().Export();
var container = new ContainerConfiguration()
.WithPart <ConventionConsumer>(rb)
.WithParts(typeof(ValueA), typeof(ValueB))
.WithProvider(new DictionaryExportDescriptorProvider())
.CreateContainer();
var consumer = container.GetExport <ConventionConsumer>();
Assert.Equal(2, consumer.Values.Count());
}
public void DependenciesOfSharedPartsAreResolvedInTheGlobalScope()
{
var cc = new ContainerConfiguration()
.WithParts(typeof(GloballySharedWithDependency), typeof(A), typeof(DataConsistencyBoundaryProvider))
.CreateContainer();
var s = cc.GetExport <DataConsistencyBoundaryProvider>().SharingScopeFactory.CreateExport();
var g = s.Value.GetExport <GloballySharedWithDependency>();
s.Dispose();
var a = (A)g.A;
Assert.False(a.IsDisposed);
cc.Dispose();
Assert.True(a.IsDisposed);
}
public void NotifyImportsSatisfiedTwice_ShouldSucceed()
{
var builder = new ConventionBuilder();
builder.ForTypesMatching(t => true).NotifyImportsSatisfied(mi => mi.Name == "OnImportsSatisfied1" || mi.Name == "OnImportsSatisfied2");
var container = new ContainerConfiguration()
.WithPart <OnImportsSatisfiedMultipleClass>(builder)
.WithPart <ExportValues>(builder)
.CreateContainer();
var test = container.GetExport <OnImportsSatisfiedMultipleClass>();
Assert.NotNull(test.P1);
Assert.NotNull(test.P2);
Assert.Equal(6, test.OnImportsSatisfiedInvoked);
}
public override Action GetOperation()
{
var c = new ContainerConfiguration()
.WithPart(typeof(X))
.WithPart(typeof(XFactory))
.CreateContainer();
var xf = c.GetExport <XFactory>();
return(() =>
{
var x = xf.CreateX();
var unused = x.Value;
x.Dispose();
});
}
public void ConventionsCanApplyExportsToInheritedProperties()
{
var conventions = new ConventionBuilder();
conventions.ForType <DerivedFromBaseWithExport>()
.ExportProperty(b => b.Exported);
var container = new ContainerConfiguration()
.WithDefaultConventions(conventions)
.WithParts(typeof(DerivedFromBaseWithExport))
.CreateContainer();
var s = container.GetExport <string>();
Assert.Equal("A", s);
}
public void NotifyImportsSatisfiedTwice_ShouldSucceed()
{
var builder = new ConventionBuilder();
builder.ForType <OnImportsSatisfiedMultipleClass>().NotifyImportsSatisfied(p => p.OnImportsSatisfied1());
builder.ForType <OnImportsSatisfiedMultipleClass>().NotifyImportsSatisfied(p => p.OnImportsSatisfied2());
var container = new ContainerConfiguration()
.WithPart <OnImportsSatisfiedMultipleClass>(builder)
.WithPart <ExportValues>(builder)
.CreateContainer();
var test = container.GetExport <OnImportsSatisfiedMultipleClass>();
Assert.NotNull(test.P1);
Assert.NotNull(test.P2);
Assert.Equal(6, test.OnImportsSatisfiedInvoked);
}
public void TheProductOfAnExportFactoryCanBeDisposedDuringDisposalOfTheParent()
{
var container = new ContainerConfiguration()
.WithPart <DisposesFactoryProduct>()
.WithPart <A>()
.CreateContainer();
var dfp = container.GetExport <DisposesFactoryProduct>();
dfp.CreateProduct();
var a = dfp.Product.Value as A;
container.Dispose();
Assert.True(a.IsDisposed);
}
public void ConventionBuilderExportsOpenGenerics()
{
var rb = new ConventionBuilder();
rb.ForTypesDerivedFrom <IContainer>()
.Export <IContainer>();
rb.ForTypesDerivedFrom(typeof(IRepository <>))
.Export(t => t.AsContractType(typeof(IRepository <>)));
var c = new ContainerConfiguration()
.WithParts(new Type[] { typeof(EFRepository <>), typeof(Container) }, rb)
.CreateContainer();
var r = c.GetExport <IRepository <int> >();
var fetch = r.Fetch();
}
public void Shared()
{
var parts = new[] { typeof(IHelloWorldShared), typeof(HelloWorldShared) }.AsApplicationParts();
var container = new ContainerConfiguration().WithParts( parts.ToArray(), ConventionBuilderFactory.Default.Get() ).CreateContainer();
var export = container.GetExport<IHelloWorldShared>();
Assert.IsType<HelloWorldShared>( export );
Assert.Same( export, container.GetExport<IHelloWorldShared>() );
Assert.Same( container.GetExport<HelloWorldShared>(), container.GetExport<HelloWorldShared>() );
Assert.Same( container.GetExport<HelloWorldShared>(), container.GetExport<IHelloWorldShared>() );
}
public void CreateContainer_ImportConventionsWithInheritedProperties_Success()
{
var conventions = new ConventionBuilder();
conventions.ForType <Imported>().Export();
conventions.ForType <DerivedFromBaseWithImport>()
.ImportProperty(b => b.Imported)
.Export();
CompositionHost container = new ContainerConfiguration()
.WithDefaultConventions(conventions)
.WithParts(typeof(Imported), typeof(DerivedFromBaseWithImport))
.CreateContainer();
DerivedFromBaseWithImport export = container.GetExport <DerivedFromBaseWithImport>();
Assert.IsAssignableFrom <Imported>(export.Imported);
}
public void ConventionsCanApplyImportsToInheritedProperties()
{
var conventions = new ConventionBuilder();
conventions.ForType <Imported>().Export();
conventions.ForType <DerivedFromBaseWithImport>()
.ImportProperty(b => b.Imported)
.Export();
var container = new ContainerConfiguration()
.WithDefaultConventions(conventions)
.WithParts(typeof(Imported), typeof(DerivedFromBaseWithImport))
.CreateContainer();
var dfb = container.GetExport <DerivedFromBaseWithImport>();
Assert.IsAssignableFrom(typeof(Imported), dfb.Imported);
}
public void ReadOnlyPropertiesOnMetadataViewsAreIgnored()
{
var c = new ContainerConfiguration()
.WithPart<HasOrder>()
.CreateContainer();
var l = c.GetExport<Lazy<HasOrder, ReadonlyNameOrderMetadata>>();
Assert.Equal(1, l.Metadata.Order);
}
public void VerifyAssemblyWithTwoBaseTypeWithOnlyOneExportedWorks()
{
var test = new ContainerConfiguration()
.WithAssembly(typeof(ClassWithDependecy).GetTypeInfo().Assembly)
.CreateContainer();
var b = test.GetExport<ClassWithDependecyAndSameBaseType>();
Assert.NotNull(b);
Assert.NotNull(b._dep);
Assert.Equal(b._dep.GetType(), typeof(TestDependency));
}
public void VerifyAssemblyNameCanBeUsedWithContainer()
{
var test = new ContainerConfiguration()
.WithAssembly(typeof(ClassWithDependecy).GetTypeInfo().Assembly)
.CreateContainer();
var b = test.GetExport<ClassWithDependecy>();
Assert.NotNull(b);
Assert.NotNull(b._dep);
}
public void NotifyImportsSatisfiedTwice_ShouldSucceed()
{
var builder = new ConventionBuilder();
builder.ForTypesMatching(t => true).NotifyImportsSatisfied(mi => mi.Name == "OnImportsSatisfied1" || mi.Name == "OnImportsSatisfied2");
var container = new ContainerConfiguration()
.WithPart<OnImportsSatisfiedMultipleClass>(builder)
.WithPart<ExportValues>(builder)
.CreateContainer();
var test = container.GetExport<OnImportsSatisfiedMultipleClass>();
Assert.NotNull(test.P1);
Assert.NotNull(test.P2);
Assert.Equal(6, test.OnImportsSatisfiedInvoked);
}
public void NotifyImportsSatisfiedPropertiesAndFields_ShouldSucceed()
{
var builder = new ConventionBuilder();
builder.ForTypesMatching(t => true).NotifyImportsSatisfied(mi => mi.Name == "OnImportsSatisfied5" || mi.Name == "OnImportsSatisfied6");
var container = new ContainerConfiguration()
.WithPart<OnImportsSatisfiedTestClassPropertiesAndFields>(builder)
.WithPart<ExportValues>(builder)
.CreateContainer();
var test = container.GetExport<OnImportsSatisfiedTestClassPropertiesAndFields>();
Assert.NotNull(test.P1);
Assert.NotNull(test.P2);
Assert.Equal(0, test.OnImportsSatisfiedInvoked);
}
public void NotifyImportsSatisfiedTwice_ShouldSucceed()
{
var builder = new ConventionBuilder();
builder.ForType<OnImportsSatisfiedMultipleClass>().NotifyImportsSatisfied(p => p.OnImportsSatisfied1());
builder.ForType<OnImportsSatisfiedMultipleClass>().NotifyImportsSatisfied(p => p.OnImportsSatisfied2());
var container = new ContainerConfiguration()
.WithPart<OnImportsSatisfiedMultipleClass>(builder)
.WithPart<ExportValues>(builder)
.CreateContainer();
var test = container.GetExport<OnImportsSatisfiedMultipleClass>();
Assert.NotNull(test.P1);
Assert.NotNull(test.P2);
Assert.Equal(6, test.OnImportsSatisfiedInvoked);
}
public void TheProductOfAnExportFactoryCanBeDisposedDuringDisposalOfTheParent()
{
var container = new ContainerConfiguration()
.WithPart<DisposesFactoryProduct>()
.WithPart<A>()
.CreateContainer();
var dfp = container.GetExport<DisposesFactoryProduct>();
dfp.CreateProduct();
var a = dfp.Product.Value as A;
container.Dispose();
Assert.True(a.IsDisposed);
}
public void NotifyImportsSatisfiedAttributeAppliedToBaseClass_ShouldSucceed()
{
var builder = new ConventionBuilder();
builder.ForTypesMatching(t => true).NotifyImportsSatisfied(mi => mi.Name == "OnImportsSatisfied");
var container = new ContainerConfiguration()
.WithPart<OnImportsSatisfiedDerivedClass>(builder)
.WithPart<ExportValues>(builder)
.CreateContainer();
var test = container.GetExport<OnImportsSatisfiedDerivedClass>();
Assert.NotNull(test.P1);
Assert.NotNull(test.P2);
Assert.Equal(1, test.OnImportsSatisfiedInvoked);
}
public void UnsupportedMetadataViewMessageIsInformative()
{
var cc = new ContainerConfiguration().WithParts(typeof(ImportsWithMetadataInterface), typeof(ExportsWithMetadata)).CreateContainer();
var x = Assert.Throws<CompositionFailedException>(() => cc.GetExport<ImportsWithMetadataInterface>());
Assert.Equal("The type 'INamed' cannot be used as a metadata view. A metadata view must be a concrete class with a parameterless or dictionary constructor.", x.Message);
}
public void MultipleImportAttributesAreDetected()
{
var c = new ContainerConfiguration()
.WithPart<MultipleImportsOnProperty>()
.CreateContainer();
var x = Assert.Throws<CompositionFailedException>(() => c.GetExport<MultipleImportsOnProperty>());
Assert.Equal("Multiple imports have been configured for 'MultiImport'. At most one import can be applied to a single site.", x.Message);
}
public void DictionaryImportsCompatibleWithConventionBuilder()
{
var rb = new ConventionBuilder();
rb.ForType<ConventionConsumer>().Export();
var container = new ContainerConfiguration()
.WithPart<ConventionConsumer>(rb)
.WithParts(typeof(ValueA), typeof(ValueB))
.WithProvider(new DictionaryExportDescriptorProvider())
.CreateContainer();
var consumer = container.GetExport<ConventionConsumer>();
Assert.Equal(2, consumer.Values.Count());
}
public override Func<Tuple<object, Action>> GetCompositionOperation()
{
var container = new ContainerConfiguration()
.WithParts(new[]{
typeof(WebServer),
typeof(Web.OperationRoot),
typeof(Web.GlobalA),
typeof(Web.GlobalB),
typeof(Web.Transient),
typeof(Web.Wide),
typeof(Web.A),
typeof(Web.B),
typeof(Web.Long),
typeof(Web.TailA),
typeof(Web.TailB),
typeof(Web.TailC)})
.CreateContainer();
var sf = container.GetExport<WebServer>().WebScopeFactory;
return () =>
{
var x = sf.CreateExport();
return Tuple.Create<object, Action>(x.Value, x.Dispose);
};
}
public void WithoutConvention()
{
var parts = new[] { typeof(IHelloWorld), typeof(HelloWorld) }.AsApplicationParts();
var container = new ContainerConfiguration().WithParts( parts.ToArray() ).CreateContainer();
Assert.Throws<CompositionFailedException>( () => container.GetExport<IHelloWorld>() );
}
public void NotifyImportsSatisfiedAttributeAppliedToDerivedClassExportBase_ShouldSucceed()
{
var builder = new ConventionBuilder();
builder.ForType<OnImportsSatisfiedDerivedClass>().NotifyImportsSatisfied(p => p.OnImportsSatisfied());
var container = new ContainerConfiguration()
.WithPart<OnImportsSatisfiedTestClass>(builder)
.WithPart<OnImportsSatisfiedDerivedClass>(builder)
.WithPart<ExportValues>(builder)
.CreateContainer();
var test = container.GetExport<OnImportsSatisfiedTestClass>();
Assert.NotNull(test.P1);
Assert.NotNull(test.P2);
Assert.Equal(0, test.OnImportsSatisfiedInvoked);
}
public void DependenciesOfSharedPartsAreResolvedInTheGlobalScope()
{
var cc = new ContainerConfiguration()
.WithParts(typeof(GloballySharedWithDependency), typeof(A), typeof(DataConsistencyBoundaryProvider))
.CreateContainer();
var s = cc.GetExport<DataConsistencyBoundaryProvider>().SharingScopeFactory.CreateExport();
var g = s.Value.GetExport<GloballySharedWithDependency>();
s.Dispose();
var a = (A)g.A;
Assert.False(a.IsDisposed);
cc.Dispose();
Assert.True(a.IsDisposed);
}
