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 RegisterInstanceCanRegisterAStruct()
{
// Struct / ValueType ?
using (var container = new IocContainer())
{
int number = 32;
var reg1 = container.RegisterInstance(typeof(int), number);
var reg2 = container.RegisterInstance(number, "key");
// Check registrations
Assert.IsInstanceOfType(reg1, typeof(InstanceRegistration<int>));
Assert.IsInstanceOfType(reg2, typeof(InstanceRegistration<int>));
Assert.AreSame(reg1.ReturnType, typeof(int));
Assert.AreSame(reg2.ReturnType, typeof(int));
// Check index
Assert.IsTrue(container.Index.Contains(typeof(int)));
Assert.IsTrue(container.Index.Contains(typeof(int), "key"));
// Try to resolve
var result1 = (int)container.Resolve(typeof(int));
var result2 = container.Resolve<int>("key");
Assert.AreEqual(number, result1);
Assert.AreEqual(number, result2);
Assert.AreEqual(result1, result2);
}
}
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 CachedLifetimeIsDependentOnTest()
{
using (var container = new IocContainer())
{
var executionDirectory = Environment.CurrentDirectory;
// Create a file for the cached item to be dependent on
var filePath = executionDirectory + "\\DependencyFile.txt";
if (File.Exists(filePath))
File.Delete(filePath);
var dependencyFile = File.CreateText(filePath);
dependencyFile.WriteLine("This is a file that the cache item is dependent on.");
dependencyFile.Close();
var cacheDependency = new CacheDependency(filePath);
var lifetime = new CachedLifetime(cacheDependency);
container.Register<IFoo>(c => new Foo1()).SetLifetime(lifetime);
var result1 = container.Resolve<IFoo>();
var result2 = container.Resolve<IFoo>();
// Change the dependency file
dependencyFile = File.AppendText(filePath);
dependencyFile.WriteLine("Modified dependecy file.");
dependencyFile.Close();
// Need to give the system time to detect the change.
Thread.Sleep(500);
var result3 = container.Resolve<IFoo>();
// cleanup
if (File.Exists(filePath))
File.Delete(filePath);
// Assert
Assert.IsNotNull(result1);
Assert.IsNotNull(result2);
Assert.IsNotNull(result3);
Assert.AreSame(result1, result2);
Assert.AreNotSame(result1, result3);
}
}
public void CanChangeLifetimeUsingSetLifetime()
{
using (var container = new IocContainer(() => new TransientLifetime()))
{
Assert.IsInstanceOfType(container.DefaultLifetimeFactory(), typeof(TransientLifetime));
var registration = container.Register<IFoo>(c => new Foo1()).SetLifetime(new ContainerLifetime());
Assert.IsInstanceOfType(registration.Lifetime, typeof(ContainerLifetime));
var foo1 = container.Resolve<IFoo>();
var foo2 = container.Resolve<IFoo>();
Assert.AreSame(foo1, foo2);
}
}
public void CachedLifetimeManagerExtensionReturnsSameObjectIfCacheNotExpired()
{
using (var iocContainer = new IocContainer())
{
iocContainer.Register<IFoo>(c => new Foo1()).AsCached();
var result1 = iocContainer.Resolve<IFoo>();
var result2 = iocContainer.Resolve<IFoo>();
var result3 = iocContainer.Resolve<IFoo>();
Verify.That(result1).IsNotNull()
.IsTheSameObjectAs(result2)
.IsTheSameObjectAs(result3);
}
}
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 MultipleResolvesReturnDifferentInstances()
{
// Belongs to the lifetime?
using (var container = new IocContainer())
{
container.Register<IFoo>(c => new Foo1());
var result1 = container.Resolve<IFoo>();
var result2 = container.Resolve<IFoo>();
Assert.IsNotNull(result1);
Assert.IsNotNull(result2);
Assert.AreNotSame(result1, result2);
}
}
/// <summary>
/// Invoked when this page is about to be displayed in a Frame.
/// </summary>
/// <param name="e">Event data that describes how this page was reached. The Parameter
/// property is typically used to configure the page.</param>
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
var ioc = new IocContainer();
CustomRegistrations(ioc);
AutoRegistrations(ioc);
var messages = new List<string>
{
ioc.Resolve<ISomething>().Say(),
ioc.Resolve<Something>().Say(),
ioc.Resolve<ISomethingOrOther>().Say(),
ioc.Resolve<IInterfaceForBaseType>().Say(),
ioc.Resolve<IInterfaceForDerivedType>().Say(),
ioc.Resolve<ICustomInterface>().Say()
};
try
{
ioc.Resolve<Object>();
}
catch (TypeNotRegisteredException ex)
{
messages.Add(ex.Message);
}
var dialogContent = string.Empty;
messages.ForEach(m => dialogContent += m + Environment.NewLine);
await new MessageDialog(dialogContent).ShowAsync();
Application.Current.Exit();
}
public void AttemptingToResolveANonexistingEntryThrows()
{
using (var iocContainer = new IocContainer())
{
Verify.TheExpectedException(typeof(KeyNotFoundException))
.IsThrownWhen(() => iocContainer.Resolve<IFoo>("Bob"))
.AndHasAMessageThat().IsEqualTo("Munq IocContainer failed to resolve Munq.Test.IFoo");
}
}
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 Example1()
{
IIocContainer container = new IocContainer();
container.Register<IMyExample1, MyExample1>();
IMyExample1 temp = container.Resolve<IMyExample1>();
Console.WriteLine("Example 1 : {0}" ,temp.Text);
}
public Example3()
{
IIocContainer container = new IocContainer();
container.RegisterUnResolvedTypes = true;
IMyExample3 temp = container.Resolve<MyExample3>();
Console.WriteLine("Example 3 : {0}" ,temp.Text);
}
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 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 CachedLifetimeManageExtensionrReturnsDifferentObjectIfCacheExpired()
{
using (var iocContainer = new IocContainer())
{
var ireg = iocContainer.Register<IFoo>(c => new Foo1()).AsCached();
var result1 = iocContainer.Resolve<IFoo>();
var result2 = iocContainer.Resolve<IFoo>();
// simulate expiry
ireg.InvalidateInstanceCache();
var result3 = iocContainer.Resolve<IFoo>();
Verify.That(result1).IsNotNull()
.IsTheSameObjectAs(result2)
.IsNotTheSameObjectAs(result3);
Verify.That(result3).IsNotNull();
}
}
public Example2()
{
/*
* Registration using attributes.
* Demonstrates a type with an interface and a type without an interface
*/
IIocContainer container = new IocContainer();
container.RegisterTypesOf<RegisteredDependencyAttribute>();
IMyExample2 temp = container.Resolve<IMyExample2>();
Console.WriteLine("Example 2 : {0}" ,temp.Text);
MyExample2a temp2 = container.Resolve<MyExample2a>();
Console.WriteLine("Example 2a : {0}", temp2.Text);
}
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 ResolveUsingKeyReturnsInstanceOfExpectedType()
{
using (var container = new IocContainer())
{
container.Register<IFoo>(c => new Foo1(), "TheKey");
var result = container.Resolve(typeof(IFoo), "TheKey");
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(IFoo));
Assert.IsInstanceOfType(result, typeof(Foo1));
}
}
public static void Configure(IocContainer container)
{
const string binarySerializer = "Binary";
const string jsonSerializer = "Json";
container.Register<IIdentityProvider, UniqueIdentityProvider>();
container.Register<ISerializer, JsonSerializer>(jsonSerializer);
container.Register<ISerializer, BinaryBase64Serializer>(binarySerializer);
container.Register<ISerializer>(
() => new SpecializedSerializer(container.Resolve<ISerializer>(binarySerializer),
container.Resolve<ISerializer>(jsonSerializer)));
try
{
container.Scan.ScanAllAssemblies("XDMessaging.*.dll");
}
catch (IocScannerException e)
{
throw new XDMessagingException("Error loading transport assembly. Grant read/list contents permissions on the application directory. If executing from a network share, add <loadFromRemoteSources enabled=\"true\" /> to the runtime section of the app.config.", e);
}
}
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));
}
}
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 CachedLifetimeReturnsDifferentInstanceIfCacheExpired()
{
using (var container = new IocContainer())
{
var reg = container.Register<IFoo>(c => new Foo1()).SetLifetime(new CachedLifetime());
var result1 = container.Resolve<IFoo>();
var result2 = container.Resolve<IFoo>();
// Simulate expiry - how ??????
// Create Reset/Clear method on Lifetime ?
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 CachedLifetimeCallbackIsCalledWhenItemRemovedFromCache()
{
using (var container = new IocContainer())
{
var lifetime = new CachedLifetime(new TimeSpan(0, 0, 1), itemRemovedCallback: RemovedCallback);
container.Register<IFoo>(c => new Foo1()).SetLifetime(lifetime);
_itemRemoved = false;
var result1 = container.Resolve<IFoo>();
// Simulate expiry
Thread.Sleep(2000);
var result2 = container.Resolve<IFoo>();
// Assert
Assert.IsNotNull(result1);
Assert.IsNotNull(result2);
Assert.AreNotSame(result1, result2);
Assert.IsTrue(_itemRemoved);
Assert.IsTrue(_reason == CacheItemRemovedReason.Expired);
}
}
public void ResolveByTypeOrKeyResolvesToDifferentTypes()
{
using (var container = new IocContainer())
{
container.Register<IFoo>(c => new Foo1());
container.Register<IFoo>(c => new Foo2(), "Foo1");
container.Register<IFoo>(c => new Foo2(), "Foo2");
container.Register<IBar>(c => new Bar1(), "Foo1"); // same key but different type
// Act
var result1 = container.Resolve<IFoo>();
var result2 = container.Resolve<IFoo>("Foo1");
var result3 = container.Resolve<IFoo>("Foo2");
var result4 = container.Resolve<IBar>("Foo1");
// Assert
Assert.IsNotNull(result1);
Assert.IsNotNull(result2);
Assert.IsNotNull(result3);
Assert.IsNotNull(result4);
Assert.IsInstanceOfType(result1, typeof(Foo1));
Assert.IsInstanceOfType(result2, typeof(Foo2));
Assert.IsInstanceOfType(result3, typeof(Foo2));
Assert.IsInstanceOfType(result4, typeof(Bar1));
Assert.AreNotSame(result1, result2);
Assert.AreNotSame(result1, result3);
Assert.AreNotSame(result1, result4);
Assert.AreNotSame(result2, result3);
Assert.AreNotSame(result2, result4);
Assert.AreNotSame(result3, result4);
}
}
public void CompileUsingKeyDoesntBreakUsingCompileModeDynamicWhenUsingInstanceRegistrationOrContainerLifetime()
{
// Test that InstanceRegistration and ContainerLifetime works using CompileMode Dynamic (should not be inlined)
using (var container = new IocContainer(defaultCompileMode: CompileMode.Dynamic))
{
var barInstance = new Bar1();
var reg1 = container.Register<IFoo, Foo1>("FirstKey").WithContainerLifetime();
var reg2 = container.RegisterInstance<IBar>(barInstance, "SecondKey");
var reg3 = container.Register<IFooBar>(x => new FooBar(x.Resolve<IFoo>("FirstKey"), x.Resolve<IBar>("SecondKey")));
container.Compile();
var res1 = container.Resolve<IFooBar>();
var res2 = container.Resolve<IFooBar>();
// Assert
Assert.AreNotSame(res1, res2);
Assert.AreSame(barInstance, res1.Bar);
Assert.AreSame(res1.Foo, res2.Foo);
}
}
/// <summary>
/// Invoked when the application is launched normally by the end user. Other entry points
/// will be used when the application is launched to open a specific file, to display
/// search results, and so forth.
/// </summary>
/// <param server="args">Details about the launch request and process.</param>
protected async override void OnLaunched(LaunchActivatedEventArgs args)
{
var container = new IocContainer();
container.RegisterInstance(() => new ObservableLoggingMechanism(new MainThreadDispatcher()) { ShowInfo = true, ShowDebug = true });
container.RegisterFromAssemblyOf<ResponseHandler>();
Configure.Messaging()
.LoggingWith(container.Resolve<ObservableLoggingMechanism>())
.ResolveReferencesWith(container)
.RegisterHandlersFromContainer().BasedOn<IMessageConsumer>()
.UsingFilePersistence()
.UsingHttpTransport()
.AsAServerUsingAProxy("SenderServer")
.OpenChannel("TestMetroRequest")
.ForRequestReplySendingTo("TestReply@ReceiverServer")
.HandleRepliesOnMainThread()
.WithDurability()
.Sequenced()
.Initialise();
ViewModelLocator.SetContainer(container);
// Do not repeat app initialization when already running, just ensure that
// the window is active
if (args.PreviousExecutionState == ApplicationExecutionState.Running)
{
Window.Current.Activate();
return;
}
if (args.PreviousExecutionState == ApplicationExecutionState.Terminated)
{
//TODO: Load state from previously suspended application
}
// Create a Frame to act navigation context and navigate to the first page
var rootFrame = new Frame();
if (!rootFrame.Navigate(typeof(MainPage)))
{
throw new Exception("Failed to create initial page");
}
// Place the frame in the current Window and ensure that it is active
Window.Current.Content = rootFrame;
Window.Current.Activate();
}
public void RegisterInstanceCanRegisterAStruct()
{
using (var container = new IocContainer())
{
int number = 32;
var registration = container.RegisterInstance(typeof(int), number);
// Check registration
Assert.IsInstanceOfType(registration, typeof(IRegistration));
Assert.AreSame(registration.Type, typeof(int));
Assert.AreEqual(registration.Key, null);
// Try to resolve
var result = container.Resolve(typeof(int));
Assert.AreEqual(number, result);
}
}