public void ContainerScopeTryResolveWorks()
{
using (var container = new IocContainer())
{
// Register
container.Register<IFoo, Foo1>();
container.Register<IFoo, Foo2>("Key1");
container.Register<IBar, Bar1>();
using (var scope = container.GetScope())
{
IFoo instance1, instance2;
var result1 = scope.TryResolve<IFoo>(out instance1);
var result2 = scope.TryResolve<IFoo>(out instance2);
Assert.AreSame(instance1, instance2);
IFooBar instance3, instance4;
var result3 = scope.TryResolve<IFooBar>(out instance3);
var result4 = scope.TryResolve<IFooBar>(out instance4);
Assert.AreSame(instance3, instance4);
}
}
}
public void RegisterThrowsExceptionIfRegistrationAlreadyExists()
{
using (var container = new IocContainer())
{
container.Register<IFoo>(c => new Foo1());
container.Register<IFoo>(c => new Foo2());
}
}
public static IocContainer InitContainer()
{
var container = new IocContainer();
container.Register<AboutController>();
container.Register<HomeController>();
return container;
}
private void RegisterDatabase(IocContainer container)
{
SterlingEngine engine =
new SterlingEngine();
engine.Activate();
container.RegisterInstance<Domain.Database>(engine.SterlingDatabase.RegisterDatabase<Domain.Database>(new FileSystemDriver()) as Domain.Database);
container.Register<Domain.Db.ITestQuery, Domain.Db.TestQuery>();
container.Register<Domain.Db.ISubjectQuery, Domain.Db.SubjectQuery>();
}
public void VerifyThrowsExceptionWhenMissingRegistration()
{
using (var container = new IocContainer())
{
container.Register<IFoo>(c => new Foo1());
container.Register<IFooBar>(y => new FooBar((IFoo)y.Resolve(typeof(IFoo)), (IBar)y.Resolve(typeof(IBar))));
container.Verify();
}
}
public void RegisterAutoUsingKey()
{
using (var container = new IocContainer())
{
container.Register(typeof(IFoo), typeof(Foo1));
container.Register(typeof(IBar), typeof(Bar1));
var reg = container.Register(typeof(IFooBar), typeof(FooBar), "TheKey", compileMode: CompileMode.Delegate);
TestRegister(container, reg, "TheKey");
}
}
public void RegisterAutoGenericUsingKey()
{
using (var container = new IocContainer())
{
container.Register<IFoo, Foo1>();
container.Register<IBar, Bar1>();
var reg = container.Register<IFooBar, FooBar>("TheKey", compileMode: CompileMode.Delegate);
TestRegister(container, reg, "TheKey");
}
}
private static void Main()
{
var container = new IocContainer();
container.Register<SonyWalkman, SonyWalkman>();
container.Register<ITapeCassette, MyPoliceTape>();
var walkman = container.Resolve<SonyWalkman>();
Console.WriteLine(walkman.Play());
Console.ReadLine();
}
public void GetAllGenericThrowsExceptionIfTypeIsNotRegistered()
{
using (var container = new IocContainer())
{
var foo1 = container.Register<IFoo>(c => new Foo1());
var foo2 = container.Register<IFoo>("Foo", c => new Foo2());
var result = container.Index.GetAll<IBar>();
// Doesnt throw exception before it is enumerated because it uses yield return - OK ?
var test = result.Count();
}
}
static void Main()
{
var iocContainer = new IocContainer();
iocContainer.Register<Shooter, Shooter>();
iocContainer.Register<IFirearm, Handgun>();
// iocContainer.Register<IFirearm, Rifle>();
var shooter = iocContainer.Resolve<Shooter>();
shooter.Shoot();
Console.Read();
}
public Example4()
{
IIocContainer container = new IocContainer();
container.Register<IMyExample4, MyExample4>();
container.Register<IMyExample4a, MyExample4a>();
container.Register<IMyExample4b, MyExample4b>();
// constructor injection and property injection
IMyExample4 temp = container.Resolve<IMyExample4>();
Console.WriteLine("Example 4 : {0} , {1}" ,temp.Text, temp.Dates.Date);
}
public void CachedLifetimeReturnsDifferentInstanceIfSlidingTimeoutHaveExpired()
{
using (var container = new IocContainer())
{
// Expires When not Accessed For More than a specific time periode.
var lifetime = new CachedLifetime(new TimeSpan(0, 0, 1));
container.Register<IFoo>(c => new Foo1()).SetLifetime(lifetime);
var result1 = container.Resolve<IFoo>();
var result2 = container.Resolve<IFoo>();
// Simulate expiry
Thread.Sleep(2000);
var result3 = container.Resolve<IFoo>();
// Assert
Assert.IsNotNull(result1);
Assert.IsNotNull(result2);
Assert.IsNotNull(result3);
Assert.AreSame(result1, result2);
Assert.AreNotSame(result1, result3);
}
}
public void RequestLifetimeReturnsSameInstanceForSameRequest()
{
// Arrange
using (var container = new IocContainer())
{
var context1 = new FakeHttpContext("Http://fakeUrl1.com");
var context2 = new FakeHttpContext("Http://fakeUrl2.com");
HttpContextBase currentContext = null;
var lifetime = new RequestLifetime(() => currentContext); // better solution for injecting HttpContext ?
container.Register<IFoo>(c => new Foo1()).SetLifetime(lifetime);
// Act
currentContext = context1;
var result1 = container.Resolve<IFoo>();
var result2 = container.Resolve<IFoo>();
currentContext = context2;
var result3 = container.Resolve<IFoo>();
// Assert
Assert.IsNotNull(result1);
Assert.IsNotNull(result2);
Assert.IsNotNull(result3);
Assert.AreSame(result1, result2);
Assert.AreNotSame(result1, result3);
}
}
public void CachedLifetimeReturnsDifferentInstanceIfCacheExpired()
{
using (var container = new IocContainer())
{
var policy = new CacheItemPolicy()
{
SlidingExpiration = new TimeSpan(0, 0, 1)
};
container.Register<IFoo>(c => new Foo1()).WithCachedLifetime(policy);
var result1 = container.Resolve<IFoo>();
var result2 = container.Resolve<IFoo>();
Thread.Sleep(1500);
var result3 = container.Resolve<IFoo>();
// Assert
Assert.IsNotNull(result1);
Assert.IsNotNull(result2);
Assert.IsNotNull(result3);
Assert.AreSame(result1, result2);
Assert.AreNotSame(result1, result3);
}
}
public void TryGetAllReturnsAnEmptyEnumerableIfTypeIsNotRegistered()
{
using (var container = new IocContainer())
{
// Arrange
var foo1 = container.Register<IFoo>(c => new Foo1());
var foo2 = container.Register<IFoo>("Foo", c => new Foo2());
// Act
var result = container.Index.TryGetAll(typeof(IBar));
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(IEnumerable<IRegistration>));
Assert.IsTrue(result.Count() == 0);
}
}
public void CanRegisterAndResolveMultipleTypes()
{
using (var container = new IocContainer())
{
container.Register<IFoo>(c => new Foo1());
container.Register<IBar>(c => new Bar1());
var result1 = container.Resolve<IFoo>();
var result2 = container.Resolve<IBar>();
Assert.IsNotNull(result1);
Assert.IsNotNull(result2);
Assert.IsInstanceOfType(result1, typeof(Foo1));
Assert.IsInstanceOfType(result2, typeof(Bar1));
}
}
public void CachedLifetimeExtensionMethodSetsLifetime()
{
using (var container = new IocContainer(() => new TransientLifetime()))
{
var registration = container.Register<IFoo>(c => new Foo1()).WithCachedLifetime(new CacheItemPolicy());
Assert.IsTrue(registration.Lifetime is CachedLifetime);
}
}
public void SessionLifetimeExtensionMethodSetsLifetime()
{
using (var container = new IocContainer(() => new TransientLifetime()))
{
var registration = container.Register<IFoo>(c => new Foo1()).WithSessionLifetime();
Assert.IsTrue(registration.Lifetime is SessionLifetime);
}
}
public void ContainerScopeResolveWorks()
{
using (var container = new IocContainer())
{
// Register
container.Register<IFoo, Foo1>();
container.Register<IFoo, Foo2>("Key1");
container.Register<IBar, Bar1>();
using (var scope = container.GetScope())
{
var instance1 = scope.Resolve<IFoo>();
var instance2 = scope.Resolve<IFoo>();
Assert.AreSame(instance1, instance2);
}
}
}
public void SetLifetimeExtensionMethodSetsLifetime()
{
using (var container = new IocContainer(() => new ContainerLifetime()))
{
var registration = container.Register<IFoo>(c => new Foo1()).SetLifetime(new ThreadLocalLifetime());
Assert.IsTrue(registration.Lifetime is ThreadLocalLifetime);
}
}
public void RegisterWithPropertyInjectionResolvesToCorrectType()
{
using (var container = new IocContainer())
{
container.Register<IFoo>(c => new Foo1());
container.Register<IBar>(c => new Bar1());
container.Register<IFooBar>(c => new FooBar() { Foo = c.Resolve<IFoo>(), Bar = c.Resolve<IBar>() });
var instance = container.Resolve<IFooBar>();
Assert.IsNotNull(instance);
Assert.IsNotNull(instance.Foo);
Assert.IsNotNull(instance.Bar);
Assert.IsInstanceOfType(instance, typeof(FooBar));
Assert.IsInstanceOfType(instance.Foo, typeof(Foo1));
Assert.IsInstanceOfType(instance.Bar, typeof(Bar1));
}
}
public Example1()
{
IIocContainer container = new IocContainer();
container.Register<IMyExample1, MyExample1>();
IMyExample1 temp = container.Resolve<IMyExample1>();
Console.WriteLine("Example 1 : {0}" ,temp.Text);
}
public void RegisterAutoByNameWithParametersResolvesToCorrectType()
{
using (var container = new IocContainer())
{
container.Register<IFoo, Foo1>();
container.Register<IBar, Bar1>();
container.Register<IFooBar, FooBar>("Bar");
IFooBar result = container.Resolve<IFooBar>("Bar");
Assert.IsNotNull(result);
Assert.IsNotNull(result.Foo);
Assert.IsNotNull(result.Bar);
Assert.IsInstanceOfType(result, typeof(FooBar));
Assert.IsInstanceOfType(result.Foo, typeof(Foo1));
Assert.IsInstanceOfType(result.Bar, typeof(Bar1));
}
}
public void CompileCanInlineRegistrationsWithContainerLifetime()
{
// Doesnt check that Compile actually works - just that it doesnt break anything
using (var container = new IocContainer())
{
container.Register<IFoo>(x => new Foo1()).ContainerLifetime();
container.Register<IBar>(x => new Bar1());
var reg = container.Register<IFooBar>(x => new FooBar(x.Resolve<IFoo>(), x.Resolve<IBar>()));
container.Compile();
var result1 = container.Resolve<IFoo>();
var result2 = (IFooBar)container.Resolve(reg);
Assert.AreEqual(result1, result2.Foo);
}
}
public void RegistrationsWithDifferentNameResolveToDifferentTypes()
{
using (var container = new IocContainer())
{
container.Register<IFoo>(c => new Foo1(), "Foo1");
container.Register<IFoo>(c => new Foo2(), "Foo2");
var result1 = container.Resolve<IFoo>("Foo1");
var result2 = container.Resolve<IFoo>("Foo2");
Assert.IsNotNull(result1);
Assert.IsNotNull(result2);
Assert.IsInstanceOfType(result1, typeof(Foo1));
Assert.IsInstanceOfType(result2, typeof(Foo2));
Assert.AreNotSame(result1, result2);
}
}
public void IndexIsEnumerable()
{
using (var container = new IocContainer())
{
var reg1 = container.Register<IFoo>(c => new Foo1());
var reg2 = container.Register<IBar>(c => new Bar1());
var reg3 = container.Register<IBar>("Bar", c => new Bar1());
var registrations = container.Index.ToList();
Assert.IsTrue(container.Index.Count() == 3);
CollectionAssert.AllItemsAreNotNull(registrations);
CollectionAssert.AllItemsAreUnique(registrations);
CollectionAssert.Contains(registrations, reg1);
CollectionAssert.Contains(registrations, reg2);
CollectionAssert.Contains(registrations, reg3);
}
}
public void RegisterAutoByTypeResolvesToCorrectType()
{
using (var container = new IocContainer())
{
container.Register<IFoo, Foo1>();
var result = container.Resolve<IFoo>();
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(Foo1));
}
}
public void RegisterAutoByNameReturnsIConfigurableRegistration()
{
using (var container = new IocContainer())
{
var result = container.Register<IFoo, Foo1>("Bar");
Assert.IsInstanceOfType(result, typeof(IConfigurableRegistration));
Assert.AreSame(result.Type, typeof(IFoo));
Assert.AreEqual(result.Key, "Bar");
}
}
public void ResolveAllByTypeReturnsInstancesOfExpectedType()
{
using (var container = new IocContainer())
{
container.Register<IFoo>(c => new Foo1());
container.Register<IFoo>("Foo1", c => new Foo2());
container.Register<IFoo>("Foo2", c => new Foo2());
container.Register<IBar>(c => new Bar1());
var results = container.ResolveAll<IFoo>();
Assert.IsTrue(results.Count() == 3);
var resultsList = results.ToList();
CollectionAssert.AllItemsAreNotNull(resultsList);
CollectionAssert.AllItemsAreInstancesOfType(resultsList, typeof(IFoo));
CollectionAssert.AllItemsAreUnique(resultsList);
}
}
public void ResolveGenericCanUseMethod()
{
using (var container = new IocContainer(defaultCompileMode: CompileMode.Delegate))
{
container.Register<IFoo>(x => Fixed());
var result = container.Resolve<IFoo>();
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(IFoo));
Assert.IsInstanceOfType(result, typeof(Foo1));
}
}