public void ReturnSameInstanceWhenInstanceRegistered() { SimpleContainer c = new SimpleContainer(); IFoo foo1 = new Foo(); c.RegisterInstance <IFoo>(foo1); IFoo foo2 = c.Resolve <IFoo>(); IFoo foo3 = c.Resolve <IFoo>(); Assert.Equal(foo1, foo2); Assert.Equal(foo1, foo1); c.RegisterType <IBar, Bar>(false); IBar b1 = c.Resolve <IBar>(); IBar b2 = new Bar(); c.RegisterInstance <IBar>(b2); IBar b3 = c.Resolve <IBar>(); Assert.NotEqual(b1, b3); Assert.Equal(typeof(Bar), b1.GetType()); c.RegisterType <IBar, BarNew>(false); IBar b4 = c.Resolve <IBar>(); Assert.Equal(typeof(BarNew), b4.GetType()); }
public void NotResolveStringParameter() { SimpleContainer c1 = new SimpleContainer(); Assert.Throws <DependencyTypeException>(() => c1.Resolve <X>()); int p = c1.Resolve <int>(); }
public void ResolveConcreteTypeDefault() { var container = new SimpleContainer(); var instance = container.Resolve<ConcreteType>(); Assert.IsNotNull(instance); Assert.AreNotSame(container.Resolve<ConcreteType>(), instance); }
public void ResolveConcreteTypeDefault() { var container = new SimpleContainer(); var instance = container.Resolve <ConcreteType>(); Assert.IsNotNull(instance); Assert.AreNotSame(container.Resolve <ConcreteType>(), instance); }
public void SingletonField() { SimpleContainer container = new SimpleContainer(); container.RegisterType<Z>(true); Y obj1 = container.Resolve<Y>(); Y obj2 = container.Resolve<Y>(); Assert.AreSame(obj1.z, obj2.z); }
public void InstanceField() { SimpleContainer container = new SimpleContainer(); container.RegisterInstance<Z>(new Z()); Y obj1 = container.Resolve<Y>(); Y obj2 = container.Resolve<Y>(); Assert.AreSame(obj1.z, obj2.z); }
public void CreatesInstancesOfRegisteredTypes() { container.RegisterType <ExampleClass>(false); var instance = container.Resolve <ExampleClass>(); Assert.IsNotNull(instance); Assert.IsTrue(instance is ExampleClass); }
public void NotSingleton() { SimpleContainer container = new SimpleContainer(); container.RegisterType<A>(false); A obj1 = container.Resolve<A>(); A obj2 = container.Resolve<A>(); Assert.AreNotSame(obj1, obj2); }
public void ResolveNotRegisterred() { SimpleContainer c = new SimpleContainer(); Assert.ThrowsException <Exception>(() => { c.Resolve <Bar>(); }); c.RegisterType <Foo, Foo2>(false); Assert.ThrowsException <Exception>(() => { c.Resolve <Foo2>(); }); }
public void ResolveConcreteTypeSingleton() { var container = new SimpleContainer(); container.RegisterType<ConcreteType>(); var instance = container.Resolve<ConcreteType>(); Assert.AreSame(container.Resolve<ConcreteType>(), instance); }
public void ResolveConcreteTypeTransient() { var container = new SimpleContainer(); container.RegisterType<ConcreteType>(false); var instance = container.Resolve<ConcreteType>(); Assert.AreNotSame(container.Resolve<ConcreteType>(), instance); }
public void DefaultSingletonCreation() { var container = new SimpleContainer(); container.RegisterType<ITypeToResolve, ConcreteType>(); var instance = container.Resolve<ITypeToResolve>(); Assert.AreSame(container.Resolve<ITypeToResolve>(), instance); }
public void TestUnregisteredClassResolveNotEqual() { SimpleContainer container = new SimpleContainer(); ClassInheritsAbstractClass object1 = container.Resolve <ClassInheritsAbstractClass>(); ClassInheritsAbstractClass object2 = container.Resolve <ClassInheritsAbstractClass>(); Assert.AreNotEqual(object1, object2); }
public void TransientInstance() { var container = new SimpleContainer(); container.RegisterType <ITypeToResolve, ConcreteType>(false); var instance = container.Resolve <ITypeToResolve>(); Assert.AreNotSame(container.Resolve <ITypeToResolve>(), instance); }
public void UnregisteredTypeClassCreation() { SimpleContainer c = new SimpleContainer(); Foo foo1 = c.Resolve <Foo>(); Foo foo2 = c.Resolve <Foo>(); Assert.IsNotNull(foo1); Assert.AreNotEqual(foo1, foo2); }
public void ResolveConcreteTypeSingleton() { var container = new SimpleContainer(); container.RegisterType <ConcreteType>(); var instance = container.Resolve <ConcreteType>(); Assert.AreSame(container.Resolve <ConcreteType>(), instance); }
public void TestSameTypeDiffInstance() { SimpleContainer c = new SimpleContainer(); c.RegisterType <Foo>(false); Foo f1 = c.Resolve <Foo>(); Foo f2 = c.Resolve <Foo>(); Assert.AreNotEqual(f1, f2); }
public void DefaultSingletonCreation() { var container = new SimpleContainer(); container.RegisterType <ITypeToResolve, ConcreteType>(); var instance = container.Resolve <ITypeToResolve>(); Assert.AreSame(container.Resolve <ITypeToResolve>(), instance); }
public void shouldNotReturnSingleton() { SimpleContainer simpleContainer = new SimpleContainer(); simpleContainer.RegisterType <IFoo, FooImpl>(false); IFoo f1 = simpleContainer.Resolve <IFoo>(); IFoo f2 = simpleContainer.Resolve <IFoo>(); Assert.IsTrue(f1 != f2); }
public void TestRegisteringInterfaceWithSingletonAreEqual() { SimpleContainer container = new SimpleContainer(); container.RegisterType <Interface, ClassInheritsAbstractClass>(true); var object1 = container.Resolve <Interface>(); var object2 = container.Resolve <Interface>(); Assert.AreEqual(object1, object2); }
public void RegisterSingletonAfterInstance() { SimpleContainer container = new SimpleContainer(); ITest instance = new A(); container.RegisterInstance<ITest>(instance); ITest obj1 = container.Resolve<ITest>(); container.RegisterType<ITest>(true); ITest obj2 = container.Resolve<ITest>(); Assert.AreSame(obj1, obj2); }
public void TestOfSingleton() { SimpleContainer c = new SimpleContainer(); c.RegisterType <Foo>(true); Foo f1 = c.Resolve <Foo>(); Foo f2 = c.Resolve <Foo>(); Assert.AreEqual(f1, f2); }
public void TestRegisteringClassAsSingletonAreEqual() { SimpleContainer container = new SimpleContainer(); container.RegisterType <ClassInheritsAbstractClass>(true); ClassInheritsAbstractClass object1 = container.Resolve <ClassInheritsAbstractClass>(); ClassInheritsAbstractClass object2 = container.Resolve <ClassInheritsAbstractClass>(); Assert.AreEqual(object1, object2); }
public void ResolveSingletonTest() { SimpleContainer container = new SimpleContainer(); container.RegisterType <Foo>(true); Foo foo = container.Resolve <Foo>(); Foo fo2 = container.Resolve <Foo>(); Assert.AreEqual(foo, fo2); }
public void SimpleNonSingletonCreation() { SimpleContainer c = new SimpleContainer(); c.RegisterType <Foo>(false); Foo foo1 = c.Resolve <Foo>(); Foo foo2 = c.Resolve <Foo>(); Assert.AreNotEqual(foo1, foo2); }
public void Basic() { SimpleContainer sc = new SimpleContainer(); sc.RegisterType <Foo>(false); Foo f1 = sc.Resolve <Foo>(); Foo f2 = sc.Resolve <Foo>(); Assert.AreNotEqual <Foo>(f1, f2); }
public void TestSingleton() { var container = new SimpleContainer(); container.RegisterType <Foo>(true); var foo1 = container.Resolve <Foo>(); var foo2 = container.Resolve <Foo>(); Assert.That(foo1, Is.EqualTo(foo2)); }
public void Singleton() { SimpleContainer sc = new SimpleContainer(); sc.RegisterType <Foo>(true); Foo f1 = sc.Resolve <Foo>(); Foo f2 = sc.Resolve <Foo>(); Assert.AreEqual <Foo>(f1, f2); }
public void DerivingNonSingletonClassCreation() { SimpleContainer c = new SimpleContainer(); c.RegisterType <Foo, Bar>(false); Foo bar1 = c.Resolve <Foo>(); Foo bar2 = c.Resolve <Foo>(); Assert.AreNotEqual(bar1, bar2); }
public void TestDifferentInstances() { var container = new SimpleContainer(); container.RegisterType <Foo>(false); var foo1 = container.Resolve <Foo>(); var foo2 = container.Resolve <Foo>(); Assert.That(foo1, Is.Not.EqualTo(foo2)); }
public void ResolveStringParameter() { const String s1 = "ala ma kota"; SimpleContainer c = new SimpleContainer(); c.RegisterInstance <string>(s1); X x = c.Resolve <X>(); String s = c.Resolve <string>(); Assert.Equal(s1, s); }
public void ResolveShouldReturnSameInstanceWhenCalledTwice() { IContainer container = new SimpleContainer(); container.Add <ThingWithNoDependencies>(); var result1 = container.Resolve <ThingWithNoDependencies>(); var result2 = container.Resolve <ThingWithNoDependencies>(); Assert.AreSame(result1, result2); }
public void NotCreateInsanceOfInterfeceIfNotRegistered() { SimpleContainer c = new SimpleContainer(); Assert.Throws <DependencyInterfaceException>(() => c.Resolve <IFoo>()); c.RegisterType <IFoo, Foo>(false); Foo f1 = c.Resolve <Foo>(); Assert.NotNull(f1); }
public void TestMultipleResolvingAllSingletons() { SimpleContainer container = new SimpleContainer(); container.RegisterType <Interface, AbstractClassImplementingInterface>(true); container.RegisterType <AbstractClassImplementingInterface, ClassInheritsAbstractClass>(true); container.RegisterType <ClassInheritsAbstractClass, ClassInheritsClass>(true); var object1 = container.Resolve <Interface>(); var object2 = container.Resolve <Interface>(); Assert.AreEqual(object1, object2); }
public void NoResolvableConstructor() { var c = new SimpleContainer(); // wyjątek, string nie ma konstruktora bezparametrowego i nie da się rozwikłać żadnego z konstruktorów c.Resolve<ConcreteWithStringParam>(); }
public void CyclicDependencySimple() { var c = new SimpleContainer(); c.RegisterType<ITypeToResolve, ConcreteWithSimpleCyclicDependency>(); c.Resolve<ITypeToResolve>(); }
public void ResolvableSecondConstructor() { var c = new SimpleContainer(); c.RegisterType<ITypeToResolve, ConcreteType>(); var instance = c.Resolve<ConcreteWithResolvableSecondConstructor>(); Assert.IsNotNull(instance.Arg1); }
public void RegisterInstance() { var c = new SimpleContainer(); var foo1 = new ConcreteType(); c.RegisterInstance<ITypeToResolve>(foo1); var foo2 = c.Resolve<ITypeToResolve>(); Assert.AreSame(foo1, foo2); }
public void ResolveObjectWithConstructorParams() { var container = new SimpleContainer(); container.RegisterType<ITypeToResolve, ConcreteType>(); container.RegisterType<ITypeToResolveWithConstructorParams, ConcreteTypeWithConstructorParams>(); var instance = container.Resolve<ITypeToResolveWithConstructorParams>(); Assert.IsInstanceOfType(instance, typeof(ConcreteTypeWithConstructorParams)); }
public void DependencyContructor() { var c = new SimpleContainer(); c.RegisterType<ITypeToResolveWithConstructorParams, ConcreteTypeWithDependencyConstructorAttr>(); c.RegisterType<ITypeToResolve, ConcreteType>(); var foo = c.Resolve<ITypeToResolveWithConstructorParams>(); Assert.IsNotNull(foo.Arg1); Assert.IsNull(foo.Arg2); }
public void ResolveObjectWithInterface() { var container = new SimpleContainer(); container.RegisterType<ITypeToResolve, ConcreteType>(); var instance = container.Resolve<ITypeToResolve>(); Assert.IsInstanceOfType(instance, typeof(ConcreteType)); }
static void Main(string[] args) { SimpleContainer container = new SimpleContainer(); container.RegisterType<Testing>( false ); Testing t1 = container.Resolve<Testing>(); t1.foo(); TestingSingleton t2, t3; container.RegisterType<TestingSingleton>( true ); t2 = container.Resolve<TestingSingleton>(); t3 = container.Resolve<TestingSingleton>(); Console.WriteLine( t2 == t3 ); IFoo t4, t5; container.RegisterType<IFoo, TestingWithInterface>( false ); t4 = container.Resolve<IFoo>(); t4.foo(); container.RegisterType<IFoo, TestingWithInterface2>( false ); t5 = container.Resolve<IFoo>(); t5.foo(); Console.ReadKey(); }
public void ThrowExceptionIfTypeNotRegistered() { var container = new SimpleContainer(); container.Resolve<ITypeToResolve>(); }
static void ShowSimpleContainer() { SimpleContainer container = new SimpleContainer(); container.Register<IFoo>( () => new ConsoleFoo() ); container.Register<Bar>( () => { IFoo foo = container.Resolve<IFoo>(); return new Bar( foo ); } ); Bar bar = container.Resolve<Bar>(); bar.Example(); }
public void ResolvableWithInstance() { var c = new SimpleContainer(); c.RegisterInstance("ala ma kota"); // rejestruje instancję string // jest ok, zarejestrowano instancję string więc rozwikłanie konstruktora X jest możliwe c.Resolve<ConcreteWithStringParam>(); }
private static void RunWithSimpleConfiguration() { Console.Out.WriteLine(nameof(Program.RunWithSimpleConfiguration)); var container = new SimpleContainer(); container.Register<IParent>(c => new JasonAsParent()); container.Register<IChild>(c => new DependentChild(c.Resolve<IParent>())); var child = container.Resolve<IChild>(); for (var i = 0; i < 1000; i++) { child.DemandFunds(); } Console.Out.WriteLine(child.Wallet); }