public void DisableResolveAllByDefault()
{
var containerServices = new ContainerServicesBuilder().WithResolveInfoAlgorithm(new ResolveOnlyRegistrationsAlgorithm()).Build();
var concreteTypes = new[] { typeof(Implementation2), typeof(Implementation3), typeof(Implementation1) };
var container = new DependencyInjectionContainer(containerServices).RegisterMany <IAbstractionA>(concreteTypes)
.Register <ClassWithCollectionDependency>();
var resolvedInstance = container.Resolve <ClassWithCollectionDependency>();
resolvedInstance.Instances.Should().HaveCount(0).And.Subject.Should().BeAssignableTo <List <IAbstractionA> >();
}
public void DetachedChildContainer()
{
var containerServices = new ContainerServicesBuilder().WithAutomaticRegistrationFactory(new NoAutoRegistrationsAllowedFactory()).Build();
var parentContainer = new DependencyInjectionContainer(containerServices);
var childContainer = parentContainer.CreateChildContainer(new ChildContainerOptions(true));
var instance = childContainer.Register <ClassWithoutDependencies>().Resolve <ClassWithoutDependencies>();
instance.Should().NotBeNull();
parentContainer.TryGetRegistration <ClassWithoutDependencies>().Should().BeNull();
}
public void MultiLevelGenericTypes()
{
var containerServices = new ContainerServicesBuilder().DisallowAutomaticRegistrations()
.Build();
var container = new DependencyInjectionContainer(containerServices).Register(typeof(ObservableCollection <>),
options => options.UseDefaultConstructor()
.MapToAbstractions(typeof(IList <>)))
.Register(typeof(GenericTypeWithDependencyToOtherGenericType <>));
var instance = container.Resolve <GenericTypeWithDependencyToOtherGenericType <int> >();
instance.Collection.Should().BeOfType <ObservableCollection <int> >();
}
public void ExplicitelyEnableResolveAllForInstantiationDependency()
{
var containerServices = new ContainerServicesBuilder().WithResolveInfoAlgorithm(new ResolveOnlyRegistrationsAlgorithm()).Build();
var concreteTypes = new[] { typeof(Implementation1), typeof(Implementation3), typeof(Implementation2) };
var container = new DependencyInjectionContainer(containerServices).RegisterMany <IAbstractionA>(concreteTypes)
.Register <ClassWithCollectionDependency>(options => options.ConfigureInstantiationParameter <IReadOnlyList <IAbstractionA> >(parameter => parameter.SetResolveAllTo(true)));
var resolvedInstance = container.Resolve <ClassWithCollectionDependency>();
resolvedInstance.Instances.Should().HaveCount(3);
for (var i = 0; i < resolvedInstance.Instances.Count; i++)
{
resolvedInstance.Instances[i].GetType().Should().Be(concreteTypes[i]);
}
}
public void ExplicitelyResolveAllForPropertyInjection()
{
var containerServices = new ContainerServicesBuilder().WithResolveInfoAlgorithm(new ResolveOnlyRegistrationsAlgorithm()).Build();
var concreteTypes = new[] { typeof(Implementation1), typeof(Implementation3), typeof(Implementation2) };
var container = new DependencyInjectionContainer(containerServices).RegisterMany <IAbstractionA>(concreteTypes)
.Register <ClassWithCollectionDependencyOnProperty>(options => options.AddPropertyInjection(nameof(ClassWithCollectionDependencyOnProperty.Instances), dependency => dependency.SetResolveAllTo(true)));
var resolvedInstance = container.Resolve <ClassWithCollectionDependencyOnProperty>();
resolvedInstance.Instances.Should().HaveCount(3);
for (var i = 0; i < resolvedInstance.Instances.Count; i++)
{
resolvedInstance.Instances[i].GetType().Should().Be(concreteTypes[i]);
}
}
public void OverrideDependencyThatIsNotRegistered()
{
var containerServices = new ContainerServicesBuilder().WithAutomaticRegistrationFactory(new NoAutoRegistrationsAllowedFactory())
.Build();
var container = new DependencyInjectionContainer(containerServices).Register <ClassWithDependency>()
.Register <ClassWithTwoDependencies>();
var overriddenInstance = new ClassWithoutDependencies();
var dependencyOverrides = container.OverrideDependenciesFor <ClassWithTwoDependencies>()
.OverrideDependency(overriddenInstance);
var resolvedInstance = container.Resolve <ClassWithTwoDependencies>(dependencyOverrides);
resolvedInstance.A.Should().BeSameAs(overriddenInstance);
resolvedInstance.B.A.Should().BeSameAs(overriddenInstance);
}
public void ScopedExternalInstanceLifetime()
{
var containerServices = new ContainerServicesBuilder().WithAutomaticRegistrationFactory(new NoAutoRegistrationsAllowedFactory()).Build();
var parentContainer = new DependencyInjectionContainer(containerServices).PrepareScopedExternalInstance <DisposableSpy>();
var externalSpy = new DisposableSpy();
var childContainer = parentContainer.CreateChildContainer();
childContainer.AddPreparedExternalInstanceToScope(externalSpy);
var resolvedInstance = childContainer.Resolve <DisposableSpy>();
resolvedInstance.Should().BeSameAs(externalSpy);
childContainer.Dispose();
externalSpy.DisposeMustHaveBeenCalledExactlyOnce();
}
public void MultipleResolvesWithDifferentConstructedTypes()
{
var containerServices = new ContainerServicesBuilder().DisallowAutomaticRegistrations()
.Build();
var container = new DependencyInjectionContainer(containerServices).Register(typeof(ObservableCollection <>),
options => options.UseDefaultConstructor()
.UseScopedLifetime()
.MapToAbstractions(typeof(IList <>)))
.Register(typeof(GenericTypeWithDependencyToOtherGenericType <>));
using (var childContainer = container.CreateChildContainer())
{
var instance1 = childContainer.Resolve <GenericTypeWithDependencyToOtherGenericType <string> >();
instance1.Collection.Should().BeOfType <ObservableCollection <string> >();
var instance2 = childContainer.Resolve <GenericTypeWithDependencyToOtherGenericType <int> >();
instance2.Collection.Should().BeOfType <ObservableCollection <int> >();
}
}
