public void Circular_Dependency_Can_Be_Resolved_Using_Property_Injection_And_Singletons()
{
ComponentContainer container = new ComponentContainer();
container.Bind<CircularDependencyProperty1>().ToSelf().AsSingleton().WithPropertyResolution();
container.Bind<CircularDependencyProperty2>().ToSelf().AsSingleton().WithPropertyResolution();
var dependency1 = container.Resolve<CircularDependencyProperty1>();
var dependency2 = container.Resolve<CircularDependencyProperty2>();
Assert.NotNull(dependency1.Dependency);
Assert.IsInstanceOf<CircularDependencyProperty2>(dependency1.Dependency);
Assert.NotNull(dependency2.Dependency);
Assert.IsInstanceOf<CircularDependencyProperty1>(dependency2.Dependency);
}
public void Child_Container_Does_Not_Proxy_To_Parent_Container_When_Child_Container_Has_Binding()
{
ComponentContainer parent = new ComponentContainer();
parent.Bind<IBaz>().To<Baz1>().AsSingleton();
ComponentContainer child = new ComponentContainer(parent);
child.Bind<IBar>().To<Bar3>().AsSingleton();
child.Bind<IBaz>().To<Baz2>().AsSingleton();
Foo1 foo = child.Resolve<Foo1>();
Assert.IsInstanceOf(typeof(Foo1), foo);
Assert.IsInstanceOf(typeof(Bar3), foo.Bar);
Assert.IsInstanceOf(typeof(Baz2), ((Bar3)foo.Bar).Baz);
}
public void After_Call_To_Resolve_Where_New_Instance_Is_Constructed_Properties_Are_Injected()
{
ComponentContainer container = new ComponentContainer();
container.Bind<IFoo>().To<Foo1>();
container.Bind<IBar>().To<Bar1>();
container.For<PropertyInject>().Bind<IBar>().To<Bar2>();
var instance = container.Resolve<PropertyInject>();
Assert.NotNull(instance.Foo);
Assert.IsInstanceOf<Foo1>(instance.Foo);
Assert.NotNull(instance.Bar);
Assert.IsInstanceOf<Bar2>(instance.Bar);
}
public void With_Default_Bindings()
{
ComponentContainer container = new ComponentContainer();
container.Bind<IFoo>().To<Foo1>();
container.Bind<IBar>().To<Bar2>();
var instance = new PropertyInject();
container.ResolveProperties(instance);
Assert.NotNull(instance.Foo);
Assert.IsInstanceOf<Foo1>(instance.Foo);
Assert.NotNull(instance.Bar);
Assert.IsInstanceOf<Bar2>(instance.Bar);
}
public void Properties_Can_Be_Injected_When_Using_Custom_InjectAttribute()
{
ComponentContainer container = new ComponentContainer();
container.ResolveAttributeType = typeof(CustomResolveAttribute);
container.Bind<IFoo>().To<Foo1>();
container.Bind<IBar>().To<Bar1>();
CustomAttributePropertyInject instance = container.Resolve<CustomAttributePropertyInject>();
Assert.IsNotNull(instance.Foo);
Assert.IsInstanceOf<Foo1>(instance.Foo);
Assert.IsNotNull(instance.Bar);
Assert.IsInstanceOf<Bar1>(instance.Bar);
}
public void Bind_ToConstant_Where_Component_Is_Not_Instance_Of_Type_Throws_Exception()
{
ComponentContainer container = new ComponentContainer();
IBar bar = new Bar1();
IFoo foo = new Foo1(bar);
container.Bind<IBar>().ToConstant(foo);
}
public void Resolve_Interface_Uses_Default_Bindings()
{
ComponentContainer container = new ComponentContainer();
container.Bind<IBar>().To<Bar1>();
IBar bar = container.Resolve<IBar>();
Assert.IsInstanceOf(typeof(Bar1), bar);
}
private static void ConstructionViaContainer(int iterations)
{
ComponentContainer container = new ComponentContainer();
container.Bind<IFoo>().To<Foo>().AsTransient();
container.Bind<IBar>().To<Bar>().AsTransient();
container.Bind<IBaz>().To<Baz>().AsTransient();
Stopwatch stopwatch = Stopwatch.StartNew();
for (int i = 0; i < iterations; i++)
{
var foo = container.Resolve<IFoo>();
}
stopwatch.Stop();
if (outputEnabled)
Console.WriteLine("ConstructionViaContainer: " + stopwatch.Elapsed);
}
public void Bind_ToStrategy_Strategy_Is_Disposed_With_Container()
{
var strategy = new TestBindingStrategy<Bar1>(() => new Bar1());
ComponentContainer container = new ComponentContainer();
container.Bind<IBar>().ToStrategy(strategy);
container.Dispose();
Assert.IsTrue(strategy.DisposeWasCalled);
}
public void Disposing_Of_Container_Calls_Dispose_On_Singleton_Obects()
{
ComponentContainer container = new ComponentContainer();
container.Bind<DisposableObject>().ToSelf().AsSingleton();
DisposableObject obj = container.Resolve<DisposableObject>();
container.Dispose();
Assert.IsTrue(obj.WasDisposed);
}
public void Bind_ToStrategy_Calls_Strategy()
{
var strategy = new TestBindingStrategy<Bar1>(() => new Bar1());
ComponentContainer container = new ComponentContainer();
container.Bind<IBar>().ToStrategy(strategy);
var bar = container.Resolve<IBar>();
Assert.IsTrue(strategy.ResolveWasCalled);
}
public static void Main(string[] args)
{
ComponentContainer container = new ComponentContainer();
container.Bind<IBar>().To<Bar>().AsTransient();
container.Bind<Foo>().ToSelf().AsSingleton();
container.For<Foo>().Bind<IBar>().To<OtherBar>().AsSingleton();
Foo foo = container.Resolve<Foo>();
Foo foo2 = container.Resolve<Foo>();
IBar bar = container.Resolve<IBar>();
Console.WriteLine("typeof(foo.Bar) : {0}", foo.Bar.GetType());
Console.WriteLine("foo == foo2 : {0}", foo == foo2);
Console.WriteLine("typeof(bar) : {0}", bar.GetType());
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
public void Bind_ToMultiple_With_Array()
{
ComponentContainer container = new ComponentContainer();
container.Bind<IStubObject[]>().ToMultiple()
.Add<StubObjectFooConstructor>().AsTransient().WithConstructorParameter("id", "Foo")
.Add<StubObjectBarConstructor>().AsTransient().WithConstructorParameter("id", "Bar");
var obj = container.Resolve<NeedsArrayOfStubObjects>();
Assert.AreEqual(2, obj.Stubs.Length);
Assert.IsInstanceOf<StubObjectFooConstructor>(obj.Stubs[0]);
Assert.IsInstanceOf<StubObjectBarConstructor>(obj.Stubs[1]);
}
public void Bind_ToFactoryMethod_Calls_FactoryMethod_When_Resolving()
{
bool factoryMethodCalled = false;
ComponentContainer container = new ComponentContainer();
container.Bind<IBar>().ToFactoryMethod((x) =>
{
factoryMethodCalled = true;
return new Bar1();
});
IBar bar = container.Resolve<IBar>();
Assert.IsTrue(factoryMethodCalled);
}
public void AutoFactory_Does_Not_Override_Bindings()
{
bool funcInvoked = false;
ComponentContainer container = new ComponentContainer();
container.Bind<Func<IBaz>>().ToConstant(new Func<IBaz>(() =>
{
funcInvoked = true;
return new Baz2();
}));
FuncClass<IBaz> funcClass = container.Resolve<FuncClass<IBaz>>();
IBaz baz = funcClass.InvokeFunc();
Assert.IsTrue(funcInvoked);
}
public void AutoFactory_Calls_Back_To_Container_Factory_Method()
{
bool containerFactoryMethodInvoked = false;
ComponentContainer container = new ComponentContainer();
container.Bind<IBaz>().ToFactoryMethod((c) =>
{
containerFactoryMethodInvoked = true;
return new Baz2();
});
FuncClass<IBaz> funcClass = container.Resolve<FuncClass<IBaz>>();
IBaz baz = funcClass.InvokeFunc();
Assert.IsTrue(containerFactoryMethodInvoked);
}
public void Bind_To_Constant_Array_Of_Interface_Type()
{
IStubObject[] stubs = new IStubObject[]
{
new StubObject() { ID = "1" },
new StubObject() { ID = "2" },
};
ComponentContainer container = new ComponentContainer();
container.Bind<IStubObject[]>().ToConstant(stubs);
var obj = container.Resolve<NeedsArrayOfStubObjects>();
Assert.AreEqual(stubs.Length, obj.Stubs.Length);
for (int i = 0; i < stubs.Length; i++)
Assert.AreSame(stubs[i], obj.Stubs[i]);
}
public void Transient_And_Singleton_Are_Not_Ignored_By_ToMultiple()
{
ComponentContainer container = new ComponentContainer();
container.Bind<IStubObject[]>().ToMultiple()
.Add<StubObjectFooConstructor>().AsSingleton().WithConstructorParameter("id", "Foo")
.Add<StubObjectBarConstructor>().AsTransient().WithConstructorParameter("id", "Bar");
var obj1 = container.Resolve<NeedsArrayOfStubObjects>();
Assert.AreEqual(2, obj1.Stubs.Length);
Assert.IsInstanceOf<StubObjectFooConstructor>(obj1.Stubs[0]);
Assert.IsInstanceOf<StubObjectBarConstructor>(obj1.Stubs[1]);
var obj2 = container.Resolve<NeedsArrayOfStubObjects>();
Assert.AreEqual(2, obj2.Stubs.Length);
Assert.IsInstanceOf<StubObjectFooConstructor>(obj2.Stubs[0]);
Assert.IsInstanceOf<StubObjectBarConstructor>(obj2.Stubs[1]);
Assert.AreSame(obj1.Stubs[0], obj2.Stubs[0]);
Assert.AreNotSame(obj1.Stubs[1], obj2.Stubs[1]);
}
public void Bind_ToConstant_Where_Component_Is_Null_Does_Not_Throw_Exception()
{
ComponentContainer container = new ComponentContainer();
container.Bind<IBar>().ToConstant(null);
}
public void WithConstructorParameter_Is_Passed_To_Constructor()
{
ComponentContainer container = new ComponentContainer();
container.Bind<Has1Param>()
.ToSelf()
.AsTransient()
.WithConstructorParameter("name", "Steve");
var obj = container.Resolve<Has1Param>();
Assert.AreEqual("Steve", obj.Name);
}
public void WithConstructorParameter_Overrides_Specific_Bindings()
{
ComponentContainer container = new ComponentContainer();
Bar1 bar = new Bar1();
container.Bind<IFoo>().To<Foo1>()
.AsTransient()
.WithConstructorParameter("bar", bar);
container.For<IFoo>().Bind<IBar>().To<Bar2>();
var obj = container.Resolve<IFoo>();
Assert.AreSame(bar, ((Foo1)obj).Bar);
}
public void AutoFactory_Not_Constructed_For_Func_With_Params()
{
ComponentContainer container = new ComponentContainer();
container.Bind<IBaz>().To<Baz2>();
container.Resolve<FuncClassWithOneParam<string, IBaz>>();
}
public void WithPropertyValue_That_Has_No_Setter_Throws_Exception_When_Resolving()
{
ComponentContainer container = new ComponentContainer();
container.Bind<Has1PropertyWithNoSetter>().To<Has1PropertyWithNoSetter>()
.AsTransient()
.WithPropertyValue("ID", "abc");
var obj = container.Resolve<Has1PropertyWithNoSetter>();
}
public void WithPropertyResolution_Resolves_Properties_Of_Constructed_Components()
{
ComponentContainer container = new ComponentContainer();
container.Bind<IFoo>().To<Foo1>();
container.Bind<IBar>().To<Bar2>();
container.Bind<PropertyInject>().ToSelf().AsTransient().WithPropertyResolution();
var obj = container.Resolve<PropertyInject>();
Assert.NotNull(obj.Foo);
Assert.IsInstanceOf<Foo1>(obj.Foo);
Assert.NotNull(obj.Bar);
Assert.IsInstanceOf<Bar2>(obj.Bar);
}
public void Bind_ToStrategy_Where_Strategy_Returns_Null_Throws_Exception()
{
var strategy = new TestBindingStrategy<Bar1>(() => null);
ComponentContainer container = new ComponentContainer();
container.Bind<IBar>().ToStrategy(strategy);
var bar = container.Resolve<IBar>();
}
public void WithPropertyValue_Is_Set_After_Resolution()
{
ComponentContainer container = new ComponentContainer();
container.Bind<Has1Property>().To<Has1Property>()
.AsTransient()
.WithPropertyValue("ID", "abc");
var obj = container.Resolve<Has1Property>();
Assert.AreSame("abc", obj.ID);
}
public void Bind_ToFactoryMethod_Where_Return_Value_Is_Not_Assignable_To_Interface_Throws_Exception()
{
ComponentContainer container = new ComponentContainer();
container.Bind<IBar>().ToFactoryMethod((x) => new Foo1(new Bar1()));
}
public void Bind(ComponentContainer container, Type interfaceType, IList<Type> componentTypes)
{
if (container == null)
throw new ArgumentNullException("container");
if (interfaceType == null)
throw new ArgumentNullException("interfaceType");
if (componentTypes == null)
throw new ArgumentNullException("componentTypes");
if (this.InterfaceTypeFilter != null && !this.InterfaceTypeFilter(interfaceType))
return;
if (componentTypes.Count == 0)
this.UnresolvedComponent(interfaceType, false);
if (!container.HasBinding(interfaceType))
{
var componentTypesEnumerable = componentTypes.AsEnumerable();
if (this.ComponentTypesFilter != null)
componentTypesEnumerable = componentTypesEnumerable.Where(this.ComponentTypesFilter);
if (componentTypesEnumerable.Count() == 1) // One implementor so we have the default binding
{
container.Bind(interfaceType).To(componentTypesEnumerable.First()).As(this.BindType);
}
else
{
Type defaultComponentType = this.FindDefaultComponentByAttribute(interfaceType, componentTypesEnumerable);
if (defaultComponentType != null)
{
container.Bind(interfaceType).To(defaultComponentType).As(this.BindType);
}
else
{
this.UnresolvedComponent(interfaceType, true);
}
}
}
}
public void Bind_ToFactoryMethod_Where_Method_Is_Null_Throws_Exception()
{
ComponentContainer container = new ComponentContainer();
container.Bind<IBar>().ToFactoryMethod<Bar1>(null);
}
public void WithPropertyValue_That_Does_Not_Exist_Throws_Exception_When_Resolving()
{
ComponentContainer container = new ComponentContainer();
container.Bind<Has1Property>().To<Has1Property>()
.AsTransient()
.WithPropertyValue("Foo", "abc");
var obj = container.Resolve<Has1Property>();
}