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);
}
