# HG changeset patch
# User Steven Robbins
# Date 1268593254 0
# Node ID efb2e93c1d9cfea3cdfb5ae96b0b2ad6a2ec9c55
# Parent  0b294eb35ad2b5d59594af0aedfa39a80eec7f58
# Parent  a767d2a87f0f8e5fffff9f3e8148fa3404c8a73f
Merge of messenger and child containers code

diff -r 0b294eb35ad2b5d59594af0aedfa39a80eec7f58 -r efb2e93c1d9cfea3cdfb5ae96b0b2ad6a2ec9c55 .hgignore
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/.hgignore	Sun Mar 14 19:00:54 2010 +0000
@@ -0,0 +1,35 @@
+# Ignore file for Visual Studio 2008
+
+# use glob syntax
+syntax: glob
+
+# Ignore Visual Studio 2008 files
+*.obj
+*.exe
+*.pdb
+*.user
+*.aps
+*.pch
+*.vspscc
+*_i.c
+*_p.c
+*.ncb
+*.suo
+*.tlb
+*.tlh
+*.bak
+*.cache
+*.ilk
+*.log
+*.lib
+*.sbr
+*.scc
+*.cs.orig
+[Bb]in
+[Db]ebug*/
+obj/
+[Rr]elease*/
+_ReSharper*/
+[Tt]est[Rr]esult*
+[Bb]uild[Ll]og.*
+*.[Pp]ublish.xml
diff -r 0b294eb35ad2b5d59594af0aedfa39a80eec7f58 -r efb2e93c1d9cfea3cdfb5ae96b0b2ad6a2ec9c55 TinyIoC.Tests/TestData/TinyMessengerTestData.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TinyIoC.Tests/TestData/TinyMessengerTestData.cs	Sun Mar 14 19:00:54 2010 +0000
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using TinyMessenger;
+
+namespace TinyIoC.Tests.TestData
+{
+    public class TestMessage : TinyMessageBase
+    {
+        public TestMessage(object sender) : base(sender)
+        {
+            
+        }
+    }
+
+    public class TestProxy : ITinyMessageProxy
+    {
+        public ITinyMessage Message {get; private set;}
+
+        public void Deliver(ITinyMessage message, ITinyMessageSubscription subscription)
+        {
+            this.Message = message;
+            subscription.Deliver(message);
+        }
+    }
+
+}
diff -r 0b294eb35ad2b5d59594af0aedfa39a80eec7f58 -r efb2e93c1d9cfea3cdfb5ae96b0b2ad6a2ec9c55 TinyIoC.Tests/TestData/UtilityMethods.cs
--- a/TinyIoC.Tests/TestData/UtilityMethods.cs	Thu Mar 11 17:26:31 2010 +0000
+++ b/TinyIoC.Tests/TestData/UtilityMethods.cs	Sun Mar 14 19:00:54 2010 +0000
@@ -18,6 +18,7 @@
 using System.Linq;
 using System.Text;
 using TinyIoC.Tests.TestData.BasicClasses;
+using TinyMessenger;
 
 namespace TinyIoC.Tests.TestData
 {
@@ -60,5 +61,20 @@
             container.Register<TestClassDefaultCtor>(item).WithWeakReference();
         }
 
+        public static ITinyMessengerHub GetMessenger()
+        {
+            return new TinyMessengerHub();
+        }
+
+        public static void FakeDeliveryAction<T>(T message)
+            where T:ITinyMessage
+        {
+        }
+
+        public static bool FakeMessageFilter<T>(T message)
+            where T:ITinyMessage
+        {
+            return true;
+        }
     }
 }
diff -r 0b294eb35ad2b5d59594af0aedfa39a80eec7f58 -r efb2e93c1d9cfea3cdfb5ae96b0b2ad6a2ec9c55 TinyIoC.Tests/TinyIoC.Tests.csproj
--- a/TinyIoC.Tests/TinyIoC.Tests.csproj	Thu Mar 11 17:26:31 2010 +0000
+++ b/TinyIoC.Tests/TinyIoC.Tests.csproj	Sun Mar 14 19:00:54 2010 +0000
@@ -50,9 +50,11 @@
     <Compile Include="TestData\BasicClasses.cs" />
     <Compile Include="TestData\NestedClassDependencies.cs" />
     <Compile Include="TestData\NestedInterfaceDependencies.cs" />
+    <Compile Include="TestData\TinyMessengerTestData.cs" />
     <Compile Include="TestData\UtilityMethods.cs" />
     <Compile Include="TinyIoCFunctionalTests.cs" />
     <Compile Include="TinyIoCTests.cs" />
+    <Compile Include="TinyMessengerTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\TinyIoC.Tests.ExternalTypes\TinyIoC.Tests.ExternalTypes.csproj">
diff -r 0b294eb35ad2b5d59594af0aedfa39a80eec7f58 -r efb2e93c1d9cfea3cdfb5ae96b0b2ad6a2ec9c55 TinyIoC.Tests/TinyIoCTests.cs
--- a/TinyIoC.Tests/TinyIoCTests.cs	Thu Mar 11 17:26:31 2010 +0000
+++ b/TinyIoC.Tests/TinyIoCTests.cs	Sun Mar 14 19:00:54 2010 +0000
@@ -1861,5 +1861,147 @@
             Assert.IsInstanceOfType(result2, typeof(ExternalTypes.IExternalTestInterface));
         }
 
+        [TestMethod]
+        public void GetChildContainer_NoParameters_ReturnsContainerInstance()
+        {
+            var container = UtilityMethods.GetContainer();
+
+            var child = container.GetChildContainer();
+
+            Assert.IsInstanceOfType(child, typeof(TinyIoCContainer));
+        }
+
+        [TestMethod]
+        public void GetChildContainer_NoParameters_ContainerReturnedIsNewContainer()
+        {
+            var container = UtilityMethods.GetContainer();
+
+            var child = container.GetChildContainer();
+
+            Assert.IsFalse(object.ReferenceEquals(child, container));
+        }
+
+        [TestMethod]
+        public void ChildContainerResolve_TypeRegisteredWithParent_ResolvesType()
+        {
+            var container = UtilityMethods.GetContainer();
+            var child = container.GetChildContainer();
+            container.Register<ITestInterface, TestClassDefaultCtor>();
+
+            var result = child.Resolve<ITestInterface>();
+
+            Assert.IsInstanceOfType(result, typeof(TestClassDefaultCtor));
+        }
+
+        [TestMethod]
+        public void ChildContainerCanResolve_TypeRegisteredWithParent_ReturnsTrue()
+        {
+            var container = UtilityMethods.GetContainer();
+            var child = container.GetChildContainer();
+            container.Register<ITestInterface, TestClassDefaultCtor>();
+
+            var result = child.CanResolve<ITestInterface>();
+
+            Assert.IsTrue(result);
+        }
+
+        [TestMethod]
+        public void ChildContainerResolve_TypeRegisteredWithChild_ResolvesType()
+        {
+            var container = UtilityMethods.GetContainer();
+            var child = container.GetChildContainer();
+            child.Register<ITestInterface, TestClassDefaultCtor>();
+
+            var result = child.Resolve<ITestInterface>();
+
+            Assert.IsInstanceOfType(result, typeof(TestClassDefaultCtor));
+        }
+
+        [TestMethod]
+        public void ChildContainerCanResolve_TypeRegisteredWithChild_ReturnsTrue()
+        {
+            var container = UtilityMethods.GetContainer();
+            var child = container.GetChildContainer();
+            child.Register<ITestInterface, TestClassDefaultCtor>();
+
+            var result = child.CanResolve<ITestInterface>();
+
+            Assert.IsTrue(result);
+        }
+
+        [TestMethod]
+        public void ChildContainerResolve_TypeRegisteredWithParentAndChild_ResolvesChildVersion()
+        {
+            var container = UtilityMethods.GetContainer();
+            var containerInstance = new TestClassDefaultCtor();
+            var child = container.GetChildContainer();
+            var childInstance = new TestClassDefaultCtor();
+            container.Register<ITestInterface>(containerInstance);
+            child.Register<ITestInterface>(childInstance);
+
+            var result = child.Resolve<ITestInterface>();
+
+            Assert.ReferenceEquals(result, childInstance);
+        }
+
+        [TestMethod]
+        public void ChildContainerResolve_NamedOnlyRegisteredWithParent_ResolvesFromParent()
+        {
+            var container = UtilityMethods.GetContainer();
+            var containerInstance = new TestClassDefaultCtor();
+            var child = container.GetChildContainer();
+            var childInstance = new TestClassDefaultCtor();
+            container.Register<ITestInterface>(containerInstance, "Testing");
+            child.Register<ITestInterface>(childInstance);
+
+            var result = child.Resolve<ITestInterface>("Testing");
+
+            Assert.ReferenceEquals(result, containerInstance);
+        }
+
+        [TestMethod]
+        public void ChildContainerCanResolve_NamedOnlyRegisteredWithParent_ReturnsTrue()
+        {
+            var container = UtilityMethods.GetContainer();
+            var containerInstance = new TestClassDefaultCtor();
+            var child = container.GetChildContainer();
+            var childInstance = new TestClassDefaultCtor();
+            container.Register<ITestInterface>(containerInstance, "Testing");
+            child.Register<ITestInterface>(childInstance);
+
+            var result = child.CanResolve<ITestInterface>("Testing");
+
+            Assert.IsTrue(result);
+        }
+
+        [TestMethod]
+        public void ChildContainerResolve_NamedOnlyRegisteredWithParentUnnamedFallbackOn_ResolvesFromChild()
+        {
+            var container = UtilityMethods.GetContainer();
+            var containerInstance = new TestClassDefaultCtor();
+            var child = container.GetChildContainer();
+            var childInstance = new TestClassDefaultCtor();
+            container.Register<ITestInterface>(containerInstance, "Testing");
+            child.Register<ITestInterface>(childInstance);
+
+            var result = child.Resolve<ITestInterface>("Testing", new ResolveOptions() { NamedResolutionFailureAction = NamedResolutionFailureActions.AttemptUnnamedResolution });
+
+            Assert.ReferenceEquals(result, childInstance);
+        }
+
+        [TestMethod]
+        public void ChildContainerResolve_NamedOnlyRegisteredWithParentChildNoRegistrationUnnamedFallbackOn_ResolvesFromParent()
+        {
+            var container = UtilityMethods.GetContainer();
+            var containerInstance = new TestClassDefaultCtor();
+            var child = container.GetChildContainer();
+            var childInstance = new TestClassDefaultCtor();
+            container.Register<ITestInterface>(containerInstance, "Testing");
+
+            var result = child.Resolve<ITestInterface>("Testing", new ResolveOptions() { NamedResolutionFailureAction = NamedResolutionFailureActions.AttemptUnnamedResolution });
+
+            Assert.ReferenceEquals(result, childInstance);
+        }
+
     }
 }
diff -r 0b294eb35ad2b5d59594af0aedfa39a80eec7f58 -r efb2e93c1d9cfea3cdfb5ae96b0b2ad6a2ec9c55 TinyIoC.Tests/TinyMessengerTests.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TinyIoC.Tests/TinyMessengerTests.cs	Sun Mar 14 19:00:54 2010 +0000
@@ -0,0 +1,425 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using TinyIoC.Tests.TestData;
+using TinyMessenger;
+using System.Threading;
+
+namespace TinyIoC.Tests
+{
+
+    [TestClass]
+    public class TinyMessengerTests
+    {
+        [TestMethod]
+        public void TinyMessenger_Ctor_DoesNotThrow()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+        }
+
+        [TestMethod]
+        public void Subscribe_ValidDeliverAction_DoesNotThrow()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+
+            messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>));
+        }
+
+        [TestMethod]
+        public void SubScribe_ValidDeliveryAction_ReturnsRegistrationObject()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+
+            var output = messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>));
+
+            Assert.IsInstanceOfType(output, typeof(TinyMessageSubscriptionToken));
+        }
+
+        [TestMethod]
+        public void Subscribe_ValidDeliverActionWIthStrongReferences_DoesNotThrow()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+
+            messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), true);
+        }
+
+        [TestMethod]
+        public void Subscribe_ValidDeliveryActionAndFilter_DoesNotThrow()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+
+            messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>));
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(ArgumentNullException))]
+        public void Subscribe_NullDeliveryAction_Throws()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+
+            messenger.Subscribe<TestMessage>(null, new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>));
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(ArgumentNullException))]
+        public void Subscribe_NullFilter_Throws()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+
+            messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), null, new TestProxy());
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(ArgumentNullException))]
+        public void Subscribe_NullProxy_Throws()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+
+            messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>), null);
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(ArgumentNullException))]
+        public void Unsubscribe_NullSubscriptionObject_Throws()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+
+            messenger.Unsubscribe<TestMessage>(null);
+        }
+
+        [TestMethod]
+        public void Unsubscribe_PreviousSubscription_DoesNotThrow()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            var subscription = messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>));
+
+            messenger.Unsubscribe<TestMessage>(subscription);
+        }
+
+        [TestMethod]
+        public void Subscribe_PreviousSubscription_ReturnsDifferentSubscriptionObject()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            var sub1 = messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>));
+            var sub2 = messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>));
+
+            Assert.IsFalse(object.ReferenceEquals(sub1, sub2));
+        }
+
+        [TestMethod]
+        public void Subscribe_CustomProxyNoFilter_DoesNotThrow()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            var proxy = new TestProxy();
+
+            messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), proxy);
+        }
+
+        [TestMethod]
+        public void Subscribe_CustomProxyWithFilter_DoesNotThrow()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            var proxy = new TestProxy();
+
+            messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>), proxy);
+        }
+
+        [TestMethod]
+        public void Subscribe_CustomProxyNoFilterStrongReference_DoesNotThrow()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            var proxy = new TestProxy();
+
+            messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), true, proxy);
+        }
+
+        [TestMethod]
+        public void Subscribe_CustomProxyFilterStrongReference_DoesNotThrow()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            var proxy = new TestProxy();
+
+            messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>), true, proxy);
+        }
+
+        [TestMethod]
+        public void Publish_CustomProxyNoFilter_UsesCorrectProxy()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            var proxy = new TestProxy();
+            messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), proxy);
+            var message = new TestMessage(this);
+
+            messenger.Publish<TestMessage>(message);
+
+            Assert.ReferenceEquals(message, proxy.Message);
+        }
+
+        [TestMethod]
+        public void Publish_CustomProxyWithFilter_UsesCorrectProxy()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            var proxy = new TestProxy();
+            messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>), proxy);
+            var message = new TestMessage(this);
+
+            messenger.Publish<TestMessage>(message);
+
+            Assert.ReferenceEquals(message, proxy.Message);
+        }
+
+        [TestMethod]
+        public void Publish_CustomProxyNoFilterStrongReference_UsesCorrectProxy()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            var proxy = new TestProxy();
+            messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), true, proxy);
+            var message = new TestMessage(this);
+
+            messenger.Publish<TestMessage>(message);
+
+            Assert.ReferenceEquals(message, proxy.Message);
+        }
+
+        [TestMethod]
+        public void Publish_CustomProxyFilterStrongReference_UsesCorrectProxy()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            var proxy = new TestProxy();
+            messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>), true, proxy);
+            var message = new TestMessage(this);
+
+            messenger.Publish<TestMessage>(message);
+
+            Assert.ReferenceEquals(message, proxy.Message);
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(ArgumentNullException))]
+        public void Publish_NullMessage_Throws()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+
+            messenger.Publish<TestMessage>(null);
+        }
+
+        [TestMethod]
+        public void Publish_NoSubscribers_DoesNotThrow()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+
+            messenger.Publish<TestMessage>(new TestMessage(this));
+        }
+
+        [TestMethod]
+        public void Publish_Subscriber_DoesNotThrow()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>));
+
+            messenger.Publish<TestMessage>(new TestMessage(this));
+        }
+
+        [TestMethod]
+        public void Publish_SubscribedMessageNoFilter_GetsMessage()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            bool received = false;
+            messenger.Subscribe<TestMessage>((m) => { received = true; });
+
+            messenger.Publish<TestMessage>(new TestMessage(this));
+
+            Assert.IsTrue(received);
+        }
+
+        [TestMethod]
+        public void Publish_SubscribedThenUnsubscribedMessageNoFilter_DoesNotGetMessage()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            bool received = false;
+            var token = messenger.Subscribe<TestMessage>((m) => { received = true; });
+            messenger.Unsubscribe<TestMessage>(token);
+
+            messenger.Publish<TestMessage>(new TestMessage(this));
+
+            Assert.IsFalse(received);
+        }
+
+        [TestMethod]
+        public void Publish_SubscribedMessageButFiltered_DoesNotGetMessage()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            bool received = false;
+            messenger.Subscribe<TestMessage>((m) => { received = true; }, (m) => false);
+
+            messenger.Publish<TestMessage>(new TestMessage(this));
+
+            Assert.IsFalse(received);
+        }
+
+        [TestMethod]
+        public void Publish_SubscribedMessageNoFilter_GetsActualMessage()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            ITinyMessage receivedMessage = null;
+            var payload = new TestMessage(this);
+            messenger.Subscribe<TestMessage>((m) => { receivedMessage = m; });
+
+            messenger.Publish<TestMessage>(payload);
+
+            Assert.ReferenceEquals(payload, receivedMessage);
+        }
+
+        [TestMethod]
+        public void GenericTinyMessage_String_SubscribeDoesNotThrow()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            var output = string.Empty;
+            messenger.Subscribe<GenericTinyMessage<string>>((m) => { output = m.Content; });
+        }
+
+        [TestMethod]
+        public void GenericTinyMessage_String_PubishDoesNotThrow()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            messenger.Publish(new GenericTinyMessage<string>(this, "Testing"));
+        }
+
+        [TestMethod]
+        public void GenericTinyMessage_String_PubishAndSubscribeDeliversContent()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            var output = string.Empty;
+            messenger.Subscribe<GenericTinyMessage<string>>((m) => { output = m.Content; });
+            messenger.Publish(new GenericTinyMessage<string>(this, "Testing"));
+
+            Assert.AreEqual("Testing", output);
+        }
+
+        [TestMethod]
+        public void Publish_SubscriptionThrowingException_DoesNotThrow()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            messenger.Subscribe<GenericTinyMessage<string>>((m) => { throw new NotImplementedException(); });
+
+            messenger.Publish(new GenericTinyMessage<string>(this, "Testing"));
+        }
+
+        [TestMethod]
+        public void PublishAsync_NoCallback_DoesNotThrow()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+
+            messenger.PublishAsync(new TestMessage(this));
+        }
+
+        [TestMethod]
+        public void PublishAsync_NoCallback_PublishesMessage()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            bool received = false;
+            messenger.Subscribe<TestMessage>((m) => { received = true; });
+
+            messenger.PublishAsync(new TestMessage(this));
+
+            // Horrible wait loop!
+            int waitCount = 0;
+            while (!received && waitCount < 100)
+            {
+                Thread.Sleep(10);
+                waitCount++;
+            }
+            Assert.IsTrue(received);
+        }
+
+        [TestMethod]
+        public void PublishAsync_Callback_DoesNotThrow()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+
+            messenger.PublishAsync(new TestMessage(this), (r) => {string test = "Testing";});
+        }
+
+        [TestMethod]
+        public void PublishAsync_Callback_PublishesMessage()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            bool received = false;
+            messenger.Subscribe<TestMessage>((m) => { received = true; });
+
+            messenger.PublishAsync(new TestMessage(this), (r) => { string test = "Testing"; });
+
+            // Horrible wait loop!
+            int waitCount = 0;
+            while (!received && waitCount < 100)
+            {
+                Thread.Sleep(10);
+                waitCount++;
+            }
+            Assert.IsTrue(received);
+        }
+
+        [TestMethod]
+        public void PublishAsync_Callback_CallsCallback()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            bool received = false;
+            bool callbackReceived = false;
+            messenger.Subscribe<TestMessage>((m) => { received = true; });
+
+            messenger.PublishAsync(new TestMessage(this), (r) => { callbackReceived = true; });
+
+            // Horrible wait loop!
+            int waitCount = 0;
+            while (!callbackReceived && waitCount < 100)
+            {
+                Thread.Sleep(10);
+                waitCount++;
+            }
+            Assert.IsTrue(received);
+        }
+
+        [TestMethod]
+        public void CancellableGenericTinyMessage_Publish_DoesNotThrow()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            messenger.Publish<CancellableGenericTinyMessage<string>>(new CancellableGenericTinyMessage<string>(this, "Testing", () => { bool test = true; }));
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(ArgumentNullException))]
+        public void CancellableGenericTinyMessage_PublishWithNullAction_Throws()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            messenger.Publish<CancellableGenericTinyMessage<string>>(new CancellableGenericTinyMessage<string>(this, "Testing", null));
+        }
+
+        [TestMethod]
+        public void CancellableGenericTinyMessage_SubscriberCancels_CancelActioned()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            bool cancelled = false;
+            messenger.Subscribe<CancellableGenericTinyMessage<string>>((m) => { m.Cancel(); });
+
+            messenger.Publish<CancellableGenericTinyMessage<string>>(new CancellableGenericTinyMessage<string>(this, "Testing", () => { cancelled = true; }));
+
+            Assert.IsTrue(cancelled);
+        }
+
+        [TestMethod]
+        public void CancellableGenericTinyMessage_SeveralSubscribersOneCancels_CancelActioned()
+        {
+            var messenger = UtilityMethods.GetMessenger();
+            bool cancelled = false;
+            messenger.Subscribe<CancellableGenericTinyMessage<string>>((m) => { var test = 1; });
+            messenger.Subscribe<CancellableGenericTinyMessage<string>>((m) => { m.Cancel(); });
+            messenger.Subscribe<CancellableGenericTinyMessage<string>>((m) => { var test = 1; });
+
+            messenger.Publish<CancellableGenericTinyMessage<string>>(new CancellableGenericTinyMessage<string>(this, "Testing", () => { cancelled = true; }));
+
+            Assert.IsTrue(cancelled);
+        }
+    }
+}
\ No newline at end of file
diff -r 0b294eb35ad2b5d59594af0aedfa39a80eec7f58 -r efb2e93c1d9cfea3cdfb5ae96b0b2ad6a2ec9c55 TinyIoC.vsmdi
--- a/TinyIoC.vsmdi	Thu Mar 11 17:26:31 2010 +0000
+++ b/TinyIoC.vsmdi	Sun Mar 14 19:00:54 2010 +0000
@@ -3,4 +3,10 @@
   <TestList name="Lists of Tests" id="8c43106b-9dc1-4907-a29f-aa66a61bf5b6">
     <RunConfiguration id="f153e84c-ff50-47cc-8625-5bce42ff1800" name="Local Test Run" storage="localtestrun.testrunconfig" type="Microsoft.VisualStudio.TestTools.Common.TestRunConfiguration, Microsoft.VisualStudio.QualityTools.Common,   PublicKeyToken=b03f5f7f11d50a3a" />
   </TestList>
+  <TestList name="Results Not in a List" id="8c84fa94-04c1-424b-9868-57a2d4851a1d">
+    <TestLinks>
+      <TestLink id="f30224a4-0097-7c46-8d7f-52f442c9e041" name="Dispose_RegisteredDisposableInstanceWithInterface_CallsDispose" storage="tinyioc.tests\bin\debug\tinyioc.tests.dll" enabled="false" type="Microsoft.VisualStudio.TestTools.TestTypes.Unit.UnitTestElement, Microsoft.VisualStudio.QualityTools.Tips.UnitTest.ObjectModel,   PublicKeyToken=b03f5f7f11d50a3a" />
+      <TestLink id="2405d7f4-ebc6-6262-7f4e-92a4b152580a" name="Dispose_RegisteredDisposableInstance_CallsDispose" storage="tinyioc.tests\bin\debug\tinyioc.tests.dll" enabled="false" type="Microsoft.VisualStudio.TestTools.TestTypes.Unit.UnitTestElement, Microsoft.VisualStudio.QualityTools.Tips.UnitTest.ObjectModel,   PublicKeyToken=b03f5f7f11d50a3a" />
+    </TestLinks>
+  </TestList>
 </TestLists>
\ No newline at end of file
diff -r 0b294eb35ad2b5d59594af0aedfa39a80eec7f58 -r efb2e93c1d9cfea3cdfb5ae96b0b2ad6a2ec9c55 TinyIoC/TinyIoC.cs
--- a/TinyIoC/TinyIoC.cs	Thu Mar 11 17:26:31 2010 +0000
+++ b/TinyIoC/TinyIoC.cs	Sun Mar 14 19:00:54 2010 +0000
@@ -13,6 +13,10 @@
 // FITNESS FOR A PARTICULAR PURPOSE.
 //===============================================================================
 
+// Uncomment this line if you want the container to automatically
+// register the TinyMessenger messenger/event aggregator
+//#define TINYMESSENGER
+
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -87,6 +91,8 @@
                     item.Dispose();
                 }
             }
+
+            GC.SuppressFinalize(this);
         }
 
         #endregion
@@ -398,6 +404,13 @@
         #endregion
 
         #region Public API
+        #region Child Containers
+        public TinyIoCContainer GetChildContainer()
+        {
+            return new TinyIoCContainer(this);
+        }
+        #endregion
+
         #region Registration
         /// <summary>
         /// Attempt to automatically register all non-generic classes and interfaces in the current app domain.
@@ -1382,6 +1395,17 @@
 
             RegisterDefaultTypes();
         }
+
+        ~TinyIoCContainer()
+        {
+            _RegisteredTypes.Clear();
+        }
+
+        TinyIoCContainer _Parent;
+        private TinyIoCContainer(TinyIoCContainer parent) : this()
+        {
+            this._Parent = parent;
+        }
         #endregion
 
         #region Internal Methods
@@ -1449,6 +1473,12 @@
         private void RegisterDefaultTypes()
         {
             this.Register<TinyIoCContainer>(this);
+
+#if TINYMESSENGER
+            // Only register the TinyMessenger singleton if we are the root container
+            if (this._Parent != null)
+                this.Register<TinyMessenger.ITinyMessengerHub, TinyMessenger.TinyMessengerHub>();
+#endif
         }
 
         private ObjectFactoryBase GetCurrentFactory(TypeRegistration registration)
@@ -1510,8 +1540,9 @@
             }
 
             // Fail if requesting named resolution and settings set to fail if unresolved
+            // Or bubble up if we have a parent
             if (!String.IsNullOrEmpty(name) && options.NamedResolutionFailureAction == NamedResolutionFailureActions.Fail)
-                return false;
+                return (_Parent != null) ? _Parent.CanResolveInternal(registration, parameters, options) : false;
 
             // Attemped unnamed fallback container resolution if relevant and requested
             if (!String.IsNullOrEmpty(name) && options.NamedResolutionFailureAction == NamedResolutionFailureActions.AttemptUnnamedResolution)
@@ -1530,8 +1561,13 @@
                 return true;
 
             // Attempt unregistered construction if possible and requested
+            // If we cant', bubble if we have a parent
             if ((options.UnregisteredResolutionAction == UnregisteredResolutionActions.AttemptResolve) || (checkType.IsGenericType && options.UnregisteredResolutionAction == UnregisteredResolutionActions.GenericsOnly))
-                return (GetBestConstructor(checkType, parameters, options) != null) ? true : false;
+                return (GetBestConstructor(checkType, parameters, options) != null) ? true : (_Parent != null) ? _Parent.CanResolveInternal(registration, parameters, options) : false;
+
+            // Bubble resolution up the container tree if we have a parent
+            if (_Parent != null)
+                return _Parent.CanResolveInternal(registration, parameters, options);
 
             return false;
         }
@@ -1577,7 +1613,13 @@
 
             // Fail if requesting named resolution and settings set to fail if unresolved
             if (!String.IsNullOrEmpty(registration.Name) && options.NamedResolutionFailureAction == NamedResolutionFailureActions.Fail)
-                throw new TinyIoCResolutionException(registration.Type);
+            {
+                // Bubble resolution up the container tree if we have a parent
+                if (_Parent != null)
+                    return _Parent.ResolveInternal(registration, parameters, options);
+                else
+                    throw new TinyIoCResolutionException(registration.Type);
+            }
 
             // Attemped unnamed fallback container resolution if relevant and requested
             if (!String.IsNullOrEmpty(registration.Name) && options.NamedResolutionFailureAction == NamedResolutionFailureActions.AttemptUnnamedResolution)
@@ -1606,6 +1648,10 @@
                     return ConstructType(registration.Type, parameters, options);
             }
 
+            // Bubble resolution up the container tree if we have a parent
+            if (_Parent != null)
+                return _Parent.ResolveInternal(registration, parameters, options);
+
             // Unable to resolve - throw
             throw new TinyIoCResolutionException(registration.Type);
         }
@@ -1772,7 +1818,7 @@
                     {
                         property.SetValue(input, ResolveInternal(new TypeRegistration(property.PropertyType), NamedParameterOverloads.Default, resolveOptions), null);
                     }
-                    catch (Exception TinyIoCResolutionException)
+                    catch (TinyIoCResolutionException)
                     {
                         // Catch any resolution errors and ignore them
                     }
@@ -1785,6 +1831,8 @@
         public void Dispose()
         {
             _RegisteredTypes.Dispose();
+
+            GC.SuppressFinalize(this);
         }
 
         #endregion
diff -r 0b294eb35ad2b5d59594af0aedfa39a80eec7f58 -r efb2e93c1d9cfea3cdfb5ae96b0b2ad6a2ec9c55 TinyIoC/TinyIoC.cs.orig
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TinyIoC/TinyIoC.cs.orig	Sun Mar 14 19:00:54 2010 +0000
@@ -0,0 +1,1796 @@
+//===============================================================================
+// TinyIoC
+//
+// An easy to use, hassle free, Inversion of Control Container for small projects
+// and beginners alike.
+//
+// http://hg.grumpydev.com/tinyioc
+//===============================================================================
+// Copyright © Steven Robbins.  All rights reserved.
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT
+// LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+// FITNESS FOR A PARTICULAR PURPOSE.
+//===============================================================================
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+using System.Linq.Expressions;
+
+namespace TinyIoC
+{
+    #region SafeDictionary
+    public class SafeDictionary<TKey, TValue> : IDisposable
+    {
+        private readonly object _Padlock = new object();
+        private readonly Dictionary<TKey, TValue> _Dictionary = new Dictionary<TKey, TValue>();
+
+        public TValue this[TKey key]
+        {
+            set
+            {
+                lock (_Padlock)
+                {
+                    TValue current;
+                    if (_Dictionary.TryGetValue(key, out current))
+                    {
+                        var disposable = current as IDisposable;
+
+                        if (disposable != null)
+                            disposable.Dispose();
+                    }
+
+                    _Dictionary[key] = value;
+                }
+            }
+        }
+
+        public bool TryGetValue(TKey key, out TValue value)
+        {
+            lock (_Padlock)
+            {
+                return _Dictionary.TryGetValue(key, out value);
+            }
+        }
+
+        public bool Remove(TKey key)
+        {
+            lock (_Padlock)
+            {
+                return _Dictionary.Remove(key);
+            }
+        }
+
+        public void Clear()
+        {
+            lock (_Padlock)
+            {
+                _Dictionary.Clear();
+            }
+        }
+
+        #region IDisposable Members
+
+        public void Dispose()
+        {
+            lock (_Padlock)
+            {
+                var disposableItems = from item in _Dictionary.Values
+                                      where item is IDisposable
+                                      select item as IDisposable;
+
+                foreach (var item in disposableItems)
+                {
+                    item.Dispose();
+                }
+            }
+        }
+
+        #endregion
+    }
+    #endregion
+
+    #region TinyIoC Exception Types
+    public class TinyIoCResolutionException : Exception
+    {
+        private const string ERROR_TEXT = "Unable to resolve type: {0}";
+
+        public TinyIoCResolutionException(Type type)
+            : base(String.Format(ERROR_TEXT, type.FullName))
+        {
+        }
+
+        public TinyIoCResolutionException(Type type, Exception innerException)
+            : base(String.Format(ERROR_TEXT, type.FullName), innerException)
+        {
+        }
+    }
+
+    public class TinyIoCRegistrationTypeException : Exception
+    {
+        private const string REGISTER_ERROR_TEXT = "Cannot register type {0} - abstract classes or interfaces are not valid implementation types for {1}.";
+
+        public TinyIoCRegistrationTypeException(Type type, string factory)
+            : base(String.Format(REGISTER_ERROR_TEXT, type.FullName, factory))
+        {
+        }
+
+        public TinyIoCRegistrationTypeException(Type type, string factory, Exception innerException)
+            : base(String.Format(REGISTER_ERROR_TEXT, type.FullName, factory), innerException)
+        {
+        }
+    }
+
+    public class TinyIoCRegistrationException : Exception
+    {
+        private const string CONVERT_ERROR_TEXT = "Cannot convert current registration of {0} to {1}";
+
+        public TinyIoCRegistrationException(Type type, string method)
+            : base(String.Format(CONVERT_ERROR_TEXT, type.FullName, method))
+        {
+        }
+
+        public TinyIoCRegistrationException(Type type, string method, Exception innerException)
+            : base(String.Format(CONVERT_ERROR_TEXT, type.FullName, method), innerException)
+        {
+        }
+    }
+
+    public class TinyIoCWeakReferenceException : Exception
+    {
+        private const string ERROR_TEXT = "Unable to instantiate {0} - referenced object has been reclaimed";
+
+        public TinyIoCWeakReferenceException(Type type)
+            : base(String.Format(ERROR_TEXT, type.FullName))
+        {
+        }
+
+        public TinyIoCWeakReferenceException(Type type, Exception innerException)
+            : base(String.Format(ERROR_TEXT, type.FullName), innerException)
+        {
+        }
+    }
+
+    public class TinyIoCConstructorResolutionException : Exception
+    {
+        private const string ERROR_TEXT = "Unable to resolve constructor for {0} using provided Expression.";
+
+        public TinyIoCConstructorResolutionException(Type type)
+            : base(String.Format(ERROR_TEXT, type.FullName))
+        {
+        }
+
+        public TinyIoCConstructorResolutionException(Type type, Exception innerException)
+            : base(String.Format(ERROR_TEXT, type.FullName), innerException)
+        {
+        }
+
+        public TinyIoCConstructorResolutionException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+
+        public TinyIoCConstructorResolutionException(string message)
+            : base(message)
+        {
+        }
+    }
+
+    public class TinyIoCAutoRegistrationException : Exception
+    {
+        private const string ERROR_TEXT = "Duplicate implementation of type {0} found ({1}).";
+        
+        public TinyIoCAutoRegistrationException(Type registerType, IEnumerable<Type> types)
+            : base(String.Format(ERROR_TEXT, registerType, GetTypesString(types)))
+        {
+        }
+
+        public TinyIoCAutoRegistrationException(Type registerType, IEnumerable<Type> types, Exception innerException)
+            : base(String.Format(ERROR_TEXT, registerType, GetTypesString(types)), innerException)
+        {
+        }
+
+        private static string GetTypesString(IEnumerable<Type> types)
+        {
+            var typeNames = from type in types
+                            select type.FullName;
+
+            return string.Join(",", typeNames.ToArray());
+        }
+    }
+    #endregion
+
+    #region Public Setup / Settings Classes
+    /// <summary>
+    /// Name/Value pairs for specifying "user" parameters when resolving
+    /// </summary>
+    public sealed class NamedParameterOverloads : Dictionary<string, object>
+    {
+        public static NamedParameterOverloads FromIDictionary(IDictionary<string, object> data)
+        {
+            return data as NamedParameterOverloads ?? new NamedParameterOverloads(data);
+        }
+
+        public NamedParameterOverloads()
+        { 
+        }
+
+        public NamedParameterOverloads(IDictionary<string, object> data) : base(data) 
+        { 
+        }
+
+        private static readonly NamedParameterOverloads _Default = new NamedParameterOverloads();
+
+        public static NamedParameterOverloads Default
+        {
+            get
+            {
+                return _Default;
+            }
+        }
+    }
+
+    public enum UnregisteredResolutionActions
+    {
+        /// <summary>
+        /// Attempt to resolve type, even if the type isn't registered.
+        /// 
+        /// Registered types/options will always take precedence.
+        /// </summary>
+        AttemptResolve,
+
+        /// <summary>
+        /// Fail resolution if type not explicitly registered
+        /// </summary>
+        Fail,
+
+        /// <summary>
+        /// Attempt to resolve unregistered type if requested type is generic
+        /// and no registration exists for the specific generic parameters used.
+        /// 
+        /// Registered types/options will always take precedence.
+        /// </summary>
+        GenericsOnly
+    }
+
+    public enum NamedResolutionFailureActions
+    {
+        AttemptUnnamedResolution,
+        Fail
+    }
+
+    /// <summary>
+    /// Resolution settings
+    /// </summary>
+    public sealed class ResolveOptions
+    {
+        private static readonly ResolveOptions _Default = new ResolveOptions();
+
+        private UnregisteredResolutionActions _UnregisteredResolutionAction = UnregisteredResolutionActions.AttemptResolve;
+        public UnregisteredResolutionActions UnregisteredResolutionAction
+        {
+            get { return _UnregisteredResolutionAction; }
+            set { _UnregisteredResolutionAction = value; }
+        }
+
+        private NamedResolutionFailureActions _NamedResolutionFailureAction = NamedResolutionFailureActions.Fail;
+        public NamedResolutionFailureActions NamedResolutionFailureAction
+        {
+            get { return _NamedResolutionFailureAction; }
+            set { _NamedResolutionFailureAction = value; }
+        }
+
+        public static ResolveOptions Default
+        {
+            get
+            {
+                return _Default;
+            }
+        }
+    }
+    #endregion
+
+    public sealed class TinyIoCContainer : IDisposable
+    {
+        #region "Fluent" API
+        /// <summary>
+        /// Registration options for "fluent" API
+        /// </summary>
+        /// <typeparam name="RegisterType">Registered type</typeparam>
+        /// <typeparam name="RegisterImplementation">Implementation type for construction of RegisteredType</typeparam>
+        public sealed class RegisterOptions
+        {
+            private TinyIoCContainer _Container;
+            private TypeRegistration _Registration;
+
+            public RegisterOptions(TinyIoCContainer container, TypeRegistration registration)
+            {
+                _Container = container;
+                _Registration = registration;
+            }
+
+            /// <summary>
+            /// Make registration a singleton (single instance) if possible
+            /// </summary>
+            /// <returns>RegisterOptions</returns>
+            /// <exception cref="TinyIoCInstantiationTypeException"></exception>
+            public RegisterOptions AsSingleton()
+            {
+                var currentFactory = _Container.GetCurrentFactory(_Registration);
+
+                if (currentFactory == null)
+                    throw new TinyIoCRegistrationException(_Registration.Type, "singleton");
+
+                return _Container.AddUpdateRegistration(_Registration, currentFactory.SingletonVariant);
+            }
+
+            /// <summary>
+            /// Make registration multi-instance if possible
+            /// </summary>
+            /// <returns>RegisterOptions</returns>
+            /// <exception cref="TinyIoCInstantiationTypeException"></exception>
+            public RegisterOptions AsMultiInstance()
+            {
+                var currentFactory = _Container.GetCurrentFactory(_Registration);
+
+                if (currentFactory == null)
+                    throw new TinyIoCRegistrationException(_Registration.Type, "multi-instance");
+
+                return _Container.AddUpdateRegistration(_Registration, currentFactory.MultiInstanceVariant);
+            }
+
+            /// <summary>
+            /// Make registration hold a weak reference if possible
+            /// </summary>
+            /// <returns>RegisterOptions</returns>
+            /// <exception cref="TinyIoCInstantiationTypeException"></exception>
+            public RegisterOptions WithWeakReference()
+            {
+                var currentFactory = _Container.GetCurrentFactory(_Registration);
+
+                if (currentFactory == null)
+                    throw new TinyIoCRegistrationException(_Registration.Type, "weak reference");
+
+                return _Container.AddUpdateRegistration(_Registration, currentFactory.WeakReferenceVariant);
+            }
+
+            /// <summary>
+            /// Make registration hold a strong reference if possible
+            /// </summary>
+            /// <returns>RegisterOptions</returns>
+            /// <exception cref="TinyIoCInstantiationTypeException"></exception>
+            public RegisterOptions WithStrongReference()
+            {
+                var currentFactory = _Container.GetCurrentFactory(_Registration);
+
+                if (currentFactory == null)
+                    throw new TinyIoCRegistrationException(_Registration.Type, "strong reference");
+
+                return _Container.AddUpdateRegistration(_Registration, currentFactory.StrongReferenceVariant);
+            }
+
+            public RegisterOptions UsingConstructor<RegisterType>(Expression<Func<RegisterType>> constructor)
+            {
+                var lambda = constructor as LambdaExpression;
+                if (lambda == null)
+                    throw new TinyIoCConstructorResolutionException(typeof(RegisterType));
+
+                var newExpression = lambda.Body as NewExpression;
+                if (newExpression == null)
+                    throw new TinyIoCConstructorResolutionException(typeof(RegisterType));
+
+                var constructorInfo = newExpression.Constructor;
+                if (constructorInfo == null)
+                    throw new TinyIoCConstructorResolutionException(typeof(RegisterType));
+
+                var currentFactory = _Container.GetCurrentFactory(_Registration);
+                if (currentFactory == null)
+                    throw new TinyIoCConstructorResolutionException(typeof(RegisterType));
+
+                currentFactory.SetConstructor(constructorInfo);
+
+                return this;
+            }
+        }
+        #endregion
+
+        #region Public API
+        #region Registration
+        /// <summary>
+        /// Attempt to automatically register all non-generic classes and interfaces in the current app domain.
+        /// 
+        /// If more than one class implements an interface then only one implementation will be registered
+        /// although no error will be thrown.
+        /// </summary>
+        public void AutoRegister()
+        {
+            AutoRegisterInternal(AppDomain.CurrentDomain.GetAssemblies(), true);
+        }
+
+        /// <summary>
+        /// Attempt to automatically register all non-generic classes and interfaces in the current app domain.
+        /// </summary>
+        /// <param name="ignoreDuplicateImplementations">Whether to ignore duplicate implementations of an interface/base class. False=throw an exception</param>
+        /// <exception cref="TinyIoCAutoRegistrationException"/>
+        public void AutoRegister(bool ignoreDuplicateImplementations)
+        {
+            AutoRegisterInternal(AppDomain.CurrentDomain.GetAssemblies(), ignoreDuplicateImplementations);
+        }
+
+        /// <summary>
+        /// Attempt to automatically register all non-generic classes and interfaces in the specified assembly
+        /// 
+        /// If more than one class implements an interface then only one implementation will be registered
+        /// although no error will be thrown.
+        /// </summary>
+        /// <param name="assembly">Assembly to process</param>
+        public void AutoRegister(Assembly assembly)
+        {
+            AutoRegisterInternal(new Assembly[] {assembly}, true);
+        }
+
+        /// <summary>
+        /// Attempt to automatically register all non-generic classes and interfaces in the specified assembly
+        /// </summary>
+        /// <param name="assembly">Assembly to process</param>
+        /// <param name="ignoreDuplicateImplementations">Whether to ignore duplicate implementations of an interface/base class. False=throw an exception</param>
+        /// <exception cref="TinyIoCAutoRegistrationException"/>
+        public void AutoRegister(Assembly assembly, bool ignoreDuplicateImplementations)
+        {
+            AutoRegisterInternal(new Assembly[] {assembly}, ignoreDuplicateImplementations);
+        }
+
+        /// <summary>
+        /// Attempt to automatically register all non-generic classes and interfaces in the specified assemblies
+        /// 
+        /// If more than one class implements an interface then only one implementation will be registered
+        /// although no error will be thrown.
+        /// </summary>
+        /// <param name="assemblies">Assemblies to process</param>
+        public void AutoRegister(IEnumerable<Assembly> assemblies)
+        {
+            AutoRegisterInternal(assemblies, true);
+        }
+
+        /// <summary>
+        /// Attempt to automatically register all non-generic classes and interfaces in the specified assemblies
+        /// </summary>
+        /// <param name="assemblies">Assemblies to process</param>
+        /// <param name="ignoreDuplicateImplementations">Whether to ignore duplicate implementations of an interface/base class. False=throw an exception</param>
+        /// <exception cref="TinyIoCAutoRegistrationException"/>
+        public void AutoRegister(IEnumerable<Assembly> assemblies, bool ignoreDuplicateImplementations)
+        {
+            AutoRegisterInternal(assemblies, ignoreDuplicateImplementations);
+        }
+
+        /// <summary>
+        /// Creates/replaces a container class registration with default options.
+        /// </summary>
+        /// <typeparam name="RegisterImplementation">Type to register</typeparam>
+        /// <returns>RegisterOptions for fluent API</returns>
+        public RegisterOptions Register<RegisterType>()
+            where RegisterType : class
+        {
+            return RegisterInternal(typeof(RegisterType), typeof(RegisterType), string.Empty, GetDefaultObjectFactory<RegisterType, RegisterType>());
+        }
+
+        /// <summary>
+        /// Creates/replaces a named container class registration with default options.
+        /// </summary>
+        /// <typeparam name="RegisterImplementation">Type to register</typeparam>
+        /// <param name="name">Name of registration</param>
+        /// <returns>RegisterOptions for fluent API</returns>
+        public RegisterOptions Register<RegisterType>(string name)
+            where RegisterType : class
+        {
+            return RegisterInternal(typeof(RegisterType), typeof(RegisterType), name, GetDefaultObjectFactory<RegisterType, RegisterType>());
+        }
+
+        /// <summary>
+        /// Creates/replaces a container class registration with a given implementation and default options.
+        /// </summary>
+        /// <typeparam name="RegisterType">Type to register</typeparam>
+        /// <typeparam name="RegisterImplementation">Type to instantiate that implements RegisterType</typeparam>
+        /// <returns>RegisterOptions for fluent API</returns>
+        public RegisterOptions Register<RegisterType, RegisterImplementation>()
+            where RegisterType : class
+            where RegisterImplementation : class, RegisterType
+        {
+            return RegisterInternal(typeof(RegisterType), typeof(RegisterImplementation), string.Empty, GetDefaultObjectFactory<RegisterType, RegisterImplementation>());
+        }
+
+        /// <summary>
+        /// Creates/replaces a named container class registration with a given implementation and default options.
+        /// </summary>
+        /// <typeparam name="RegisterType">Type to register</typeparam>
+        /// <typeparam name="RegisterImplementation">Type to instantiate that implements RegisterType</typeparam>
+        /// <param name="name">Name of registration</param>
+        /// <returns>RegisterOptions for fluent API</returns>
+        public RegisterOptions Register<RegisterType, RegisterImplementation>(string name)
+            where RegisterType : class
+            where RegisterImplementation : class, RegisterType
+        {
+            return RegisterInternal(typeof(RegisterType), typeof(RegisterImplementation), name, GetDefaultObjectFactory<RegisterType, RegisterImplementation>());
+        }
+
+        /// <summary>
+        /// Creates/replaces a container class registration with a specific, strong referenced, instance.
+        /// </summary>
+        /// <typeparam name="RegisterImplementation">Type to register</typeparam>
+        /// <param name="instance">Instance of RegisterType to register</param>
+        /// <returns>RegisterOptions for fluent API</returns>
+        public RegisterOptions Register<RegisterType>(RegisterType instance)
+           where RegisterType : class
+        {
+            return RegisterInternal(typeof(RegisterType), typeof(RegisterType), string.Empty, new InstanceFactory<RegisterType, RegisterType>(instance));
+        }
+
+        /// <summary>
+        /// Creates/replaces a named container class registration with a specific, strong referenced, instance.
+        /// </summary>
+        /// <typeparam name="RegisterImplementation">Type to register</typeparam>
+        /// <param name="instance">Instance of RegisterType to register</param>
+        /// <param name="name">Name of registration</param>
+        /// <returns>RegisterOptions for fluent API</returns>
+        public RegisterOptions Register<RegisterType>(RegisterType instance, string name)
+            where RegisterType : class
+        {
+            return RegisterInternal(typeof(RegisterType), typeof(RegisterType), name, new InstanceFactory<RegisterType, RegisterType>(instance));
+        }
+
+        /// <summary>
+        /// Creates/replaces a container class registration with a specific, strong referenced, instance.
+        /// </summary>
+        /// <typeparam name="RegisterType">Type to register</typeparam>
+        /// <typeparam name="RegisterImplementation">Type of instance to register that implements RegisterType</typeparam>
+        /// <param name="instance">Instance of RegisterImplementation to register</param>
+        /// <returns>RegisterOptions for fluent API</returns>
+        public RegisterOptions Register<RegisterType, RegisterImplementation>(RegisterImplementation instance)
+            where RegisterType : class
+            where RegisterImplementation : class, RegisterType
+        {
+            return RegisterInternal(typeof(RegisterType), typeof(RegisterImplementation), string.Empty, new InstanceFactory<RegisterType, RegisterImplementation>(instance));
+        }
+
+        /// <summary>
+        /// Creates/replaces a named container class registration with a specific, strong referenced, instance.
+        /// </summary>
+        /// <typeparam name="RegisterType">Type to register</typeparam>
+        /// <typeparam name="RegisterImplementation">Type of instance to register that implements RegisterType</typeparam>
+        /// <param name="instance">Instance of RegisterImplementation to register</param>
+        /// <param name="name">Name of registration</param>
+        /// <returns>RegisterOptions for fluent API</returns>
+        public RegisterOptions Register<RegisterType, RegisterImplementation>(RegisterImplementation instance, string name)
+            where RegisterType : class
+            where RegisterImplementation : class, RegisterType
+        {
+            return RegisterInternal(typeof(RegisterType), typeof(RegisterImplementation), name, new InstanceFactory<RegisterType, RegisterImplementation>(instance));
+        }
+
+        /// <summary>
+        /// Creates/replaces a container class registration with a user specified factory
+        /// </summary>
+        /// <typeparam name="RegisterType">Type to register</typeparam>
+        /// <param name="factory">Factory/lambda that returns an instance of RegisterType</param>
+        /// <returns>RegisterOptions for fluent API</returns>
+        public RegisterOptions Register<RegisterType>(Func<TinyIoCContainer, NamedParameterOverloads, RegisterType> factory)
+            where RegisterType : class
+        {
+            return RegisterInternal(typeof(RegisterType), typeof(RegisterType), string.Empty, new DelegateFactory<RegisterType>(factory));
+        }
+
+        /// <summary>
+        /// Creates/replaces a named container class registration with a user specified factory
+        /// </summary>
+        /// <typeparam name="RegisterType">Type to register</typeparam>
+        /// <param name="factory">Factory/lambda that returns an instance of RegisterType</param>
+        /// <param name="name">Name of registation</param>
+        /// <returns>RegisterOptions for fluent API</returns>
+        public RegisterOptions Register<RegisterType>(Func<TinyIoCContainer, NamedParameterOverloads, RegisterType> factory, string name)
+            where RegisterType : class
+        {
+            return RegisterInternal(typeof(RegisterType), typeof(RegisterType), name, new DelegateFactory<RegisterType>(factory));
+        }
+
+        #endregion
+
+        #region Resolution
+        /// <summary>
+        /// Attempts to resolve a type using default options.
+        /// </summary>
+        /// <typeparam name="ResolveType">Type to resolve</typeparam>
+        /// <returns>Instance of type</returns>
+        /// <exception cref="TinyIoCResolutionException">Unable to resolve the type.</exception>
+        public ResolveType Resolve<ResolveType>()
+            where ResolveType : class
+        {
+            return ResolveInternal(new TypeRegistration(typeof(ResolveType)), NamedParameterOverloads.Default, ResolveOptions.Default) as ResolveType;
+        }
+
+        /// <summary>
+        /// Attempts to resolve a type using specified options.
+        /// </summary>
+        /// <typeparam name="ResolveType">Type to resolve</typeparam>
+        /// <param name="options">Resolution options</param>
+        /// <returns>Instance of type</returns>
+        /// <exception cref="TinyIoCResolutionException">Unable to resolve the type.</exception>
+        public ResolveType Resolve<ResolveType>(ResolveOptions options)
+            where ResolveType : class
+        {
+            return ResolveInternal(new TypeRegistration(typeof(ResolveType)), NamedParameterOverloads.Default, options) as ResolveType;
+        }
+
+        /// <summary>
+        /// Attempts to resolve a type using default options and the supplied name.
+        ///
+        /// Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
+        /// All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
+        /// </summary>
+        /// <typeparam name="ResolveType">Type to resolve</typeparam>
+        /// <param name="name">Name of registration</param>
+        /// <returns>Instance of type</returns>
+        /// <exception cref="TinyIoCResolutionException">Unable to resolve the type.</exception>
+        public ResolveType Resolve<ResolveType>(string name)
+            where ResolveType : class
+        {
+            return ResolveInternal(new TypeRegistration(typeof(ResolveType), name), NamedParameterOverloads.Default, ResolveOptions.Default) as ResolveType;
+        }
+
+        /// <summary>
+        /// Attempts to resolve a type using supplied options and  name.
+        ///
+        /// Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
+        /// All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
+        /// </summary>
+        /// <typeparam name="ResolveType">Type to resolve</typeparam>
+        /// <param name="name">Name of registration</param>
+        /// <param name="options">Resolution options</param>
+        /// <returns>Instance of type</returns>
+        /// <exception cref="TinyIoCResolutionException">Unable to resolve the type.</exception>
+        public ResolveType Resolve<ResolveType>(string name, ResolveOptions options)
+            where ResolveType : class
+        {
+            return ResolveInternal(new TypeRegistration(typeof(ResolveType), name), NamedParameterOverloads.Default, options) as ResolveType;
+        }
+
+        /// <summary>
+        /// Attempts to resolve a type using default options and the supplied constructor parameters.
+        ///
+        /// Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
+        /// All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
+        /// </summary>
+        /// <typeparam name="ResolveType">Type to resolve</typeparam>
+        /// <param name="parameters">User specified constructor parameters</param>
+        /// <returns>Instance of type</returns>
+        /// <exception cref="TinyIoCResolutionException">Unable to resolve the type.</exception>
+        public ResolveType Resolve<ResolveType>(NamedParameterOverloads parameters)
+            where ResolveType : class
+        {
+            return ResolveInternal(new TypeRegistration(typeof(ResolveType)), parameters, ResolveOptions.Default) as ResolveType;
+        }
+
+        /// <summary>
+        /// Attempts to resolve a type using specified options and the supplied constructor parameters.
+        ///
+        /// Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
+        /// All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
+        /// </summary>
+        /// <typeparam name="ResolveType">Type to resolve</typeparam>
+        /// <param name="parameters">User specified constructor parameters</param>
+        /// <param name="options">Resolution options</param>
+        /// <returns>Instance of type</returns>
+        /// <exception cref="TinyIoCResolutionException">Unable to resolve the type.</exception>
+        public ResolveType Resolve<ResolveType>(NamedParameterOverloads parameters, ResolveOptions options)
+            where ResolveType : class
+        {
+            return ResolveInternal(new TypeRegistration(typeof(ResolveType)), parameters, options) as ResolveType;
+        }
+
+        /// <summary>
+        /// Attempts to resolve a type using default options and the supplied constructor parameters and name.
+        ///
+        /// Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
+        /// All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
+        /// </summary>
+        /// <typeparam name="ResolveType">Type to resolve</typeparam>
+        /// <param name="parameters">User specified constructor parameters</param>
+        /// <param name="name">Name of registration</param>
+        /// <returns>Instance of type</returns>
+        /// <exception cref="TinyIoCResolutionException">Unable to resolve the type.</exception>
+        public ResolveType Resolve<ResolveType>(string name, NamedParameterOverloads parameters)
+            where ResolveType : class
+        {
+            return ResolveInternal(new TypeRegistration(typeof(ResolveType), name), parameters, ResolveOptions.Default) as ResolveType;
+        }
+
+        /// <summary>
+        /// Attempts to resolve a named type using specified options and the supplied constructor parameters.
+        ///
+        /// Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
+        /// All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
+        /// </summary>
+        /// <typeparam name="ResolveType">Type to resolve</typeparam>
+        /// <param name="name">Name of registration</param>
+        /// <param name="parameters">User specified constructor parameters</param>
+        /// <param name="options">Resolution options</param>
+        /// <returns>Instance of type</returns>
+        /// <exception cref="TinyIoCResolutionException">Unable to resolve the type.</exception>
+        public ResolveType Resolve<ResolveType>(string name, NamedParameterOverloads parameters, ResolveOptions options)
+            where ResolveType : class
+        {
+            return ResolveInternal(new TypeRegistration(typeof(ResolveType), name), parameters, options) as ResolveType;
+        }
+
+        /// <summary>
+        /// Attempts to predict whether a given type can be resolved with default options.
+        ///
+        /// Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
+        /// </summary>
+        /// <typeparam name="ResolveType">Type to resolve</typeparam>
+        /// <param name="name">Name of registration</param>
+        /// <returns>Bool indicating whether the type can be resolved</returns>
+        public bool CanResolve<ResolveType>()
+            where ResolveType : class
+        {
+            return CanResolveInternal(new TypeRegistration(typeof(ResolveType)), NamedParameterOverloads.Default, ResolveOptions.Default);
+        }
+
+        /// <summary>
+        /// Attempts to predict whether a given named type can be resolved with default options.
+        ///
+        /// Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
+        /// </summary>
+        /// <typeparam name="ResolveType">Type to resolve</typeparam>
+        /// <returns>Bool indicating whether the type can be resolved</returns>
+        public bool CanResolve<ResolveType>(string name)
+            where ResolveType : class
+        {
+            return CanResolveInternal(new TypeRegistration(typeof(ResolveType), name), NamedParameterOverloads.Default, ResolveOptions.Default);
+        }
+
+        /// <summary>
+        /// Attempts to predict whether a given type can be resolved with the specified options.
+        ///
+        /// Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
+        /// </summary>
+        /// <typeparam name="ResolveType">Type to resolve</typeparam>
+        /// <param name="name">Name of registration</param>
+        /// <param name="options">Resolution options</param>
+        /// <returns>Bool indicating whether the type can be resolved</returns>
+        public bool CanResolve<ResolveType>(ResolveOptions options)
+            where ResolveType : class
+        {
+            return CanResolveInternal(new TypeRegistration(typeof(ResolveType)), NamedParameterOverloads.Default, options);
+        }
+
+        /// <summary>
+        /// Attempts to predict whether a given named type can be resolved with the specified options.
+        ///
+        /// Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
+        /// </summary>
+        /// <typeparam name="ResolveType">Type to resolve</typeparam>
+        /// <param name="name">Name of registration</param>
+        /// <param name="options">Resolution options</param>
+        /// <returns>Bool indicating whether the type can be resolved</returns>
+        public bool CanResolve<ResolveType>(string name, ResolveOptions options)
+            where ResolveType : class
+        {
+            return CanResolveInternal(new TypeRegistration(typeof(ResolveType), name), NamedParameterOverloads.Default, options);
+        }
+
+        /// <summary>
+        /// Attempts to predict whether a given type can be resolved with the supplied constructor parameters and default options.
+        ///
+        /// Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
+        /// All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
+        /// 
+        /// Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
+        /// </summary>
+        /// <typeparam name="ResolveType">Type to resolve</typeparam>
+        /// <param name="parameters">User supplied named parameter overloads</param>
+        /// <returns>Bool indicating whether the type can be resolved</returns>
+        public bool CanResolve<ResolveType>(NamedParameterOverloads parameters)
+            where ResolveType : class
+        {
+            return CanResolveInternal(new TypeRegistration(typeof(ResolveType)), parameters, ResolveOptions.Default);
+        }
+
+        /// <summary>
+        /// Attempts to predict whether a given named type can be resolved with the supplied constructor parameters and default options.
+        ///
+        /// Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
+        /// All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
+        /// 
+        /// Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
+        /// </summary>
+        /// <typeparam name="ResolveType">Type to resolve</typeparam>
+        /// <param name="name">Name of registration</param>
+        /// <param name="parameters">User supplied named parameter overloads</param>
+        /// <returns>Bool indicating whether the type can be resolved</returns>
+        public bool CanResolve<ResolveType>(string name, NamedParameterOverloads parameters)
+            where ResolveType : class
+        {
+            return CanResolveInternal(new TypeRegistration(typeof(ResolveType), name), parameters, ResolveOptions.Default);
+        }
+
+        /// <summary>
+        /// Attempts to predict whether a given type can be resolved with the supplied constructor parameters options.
+        ///
+        /// Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
+        /// All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
+        /// 
+        /// Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
+        /// </summary>
+        /// <typeparam name="ResolveType">Type to resolve</typeparam>
+        /// <param name="parameters">User supplied named parameter overloads</param>
+        /// <param name="options">Resolution options</param>
+        /// <returns>Bool indicating whether the type can be resolved</returns>
+        public bool CanResolve<ResolveType>(NamedParameterOverloads parameters, ResolveOptions options)
+            where ResolveType : class
+        {
+            return CanResolveInternal(new TypeRegistration(typeof(ResolveType)), parameters, options);
+        }
+
+        /// <summary>
+        /// Attempts to predict whether a given named type can be resolved with the supplied constructor parameters options.
+        ///
+        /// Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
+        /// All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
+        /// 
+        /// Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
+        /// </summary>
+        /// <typeparam name="ResolveType">Type to resolve</typeparam>
+        /// <param name="name">Name of registration</param>
+        /// <param name="parameters">User supplied named parameter overloads</param>
+        /// <param name="options">Resolution options</param>
+        /// <returns>Bool indicating whether the type can be resolved</returns>
+        public bool CanResolve<ResolveType>(string name, NamedParameterOverloads parameters, ResolveOptions options)
+            where ResolveType : class
+        {
+            return CanResolveInternal(new TypeRegistration(typeof(ResolveType), name), parameters, options);
+        }
+
+        /// <summary>
+        /// Attempts to resolve all public property dependencies on the given object.
+        /// </summary>
+        /// <param name="input">Object to "build up"</param>
+        public void BuildUp(object input)
+        {
+            BuildUpInternal(input, ResolveOptions.Default);
+        }
+
+        /// <summary>
+        /// Attempts to resolve all public property dependencies on the given object using the given resolve options.
+        /// </summary>
+        /// <param name="input">Object to "build up"</param>
+        /// <param name="resolveOptions">Resolve options to use</param>
+        public void BuildUp(object input, ResolveOptions resolveOptions)
+        {
+            BuildUpInternal(input, resolveOptions);
+        }
+        #endregion
+        #endregion
+
+        #region Object Factories
+        private abstract class ObjectFactoryBase
+        {
+            /// <summary>
+            /// Whether to assume this factory sucessfully constructs its objects
+            /// 
+            /// Generally set to true for delegate style factories as CanResolve cannot delve
+            /// into the delegates they contain.
+            /// </summary>
+            public virtual bool AssumeConstruction { get { return false; } }
+
+            /// <summary>
+            /// The type the factory instantiates
+            /// </summary>
+            public abstract Type CreatesType { get; }
+
+            /// <summary>
+            /// Constructor to use, if specified
+            /// </summary>
+            public ConstructorInfo Constructor { get; protected set; }
+
+            /// <summary>
+            /// Create the type
+            /// </summary>
+            /// <param name="container">Container that requested the creation</param>
+            /// <param name="parameters">Any user parameters passed</param>
+            /// <returns></returns>
+            public abstract object GetObject(TinyIoCContainer container, NamedParameterOverloads parameters, ResolveOptions options);
+
+            public virtual ObjectFactoryBase SingletonVariant
+            {
+                get
+                {
+                    throw new TinyIoCRegistrationException(this.GetType(), "singleton");
+                }
+            }
+
+            public virtual ObjectFactoryBase MultiInstanceVariant
+            {
+                get
+                {
+                    throw new TinyIoCRegistrationException(this.GetType(), "multi-instance");
+                }
+            }
+
+            public virtual ObjectFactoryBase StrongReferenceVariant
+            {
+                get
+                {
+                    throw new TinyIoCRegistrationException(this.GetType(), "strong reference");
+                }
+            }
+
+            public virtual ObjectFactoryBase WeakReferenceVariant
+            {
+                get
+                {
+                    throw new TinyIoCRegistrationException(this.GetType(), "weak reference");
+                }
+            }
+
+            public virtual void SetConstructor(ConstructorInfo constructor)
+            {
+                this.Constructor = constructor;
+            }
+        }
+
+        /// <summary>
+        /// IObjectFactory that creates new instances of types for each resolution
+        /// </summary>
+        /// <typeparam name="RegisterType">Registered type</typeparam>
+        /// <typeparam name="RegisterImplementation">Type to construct to fullful request for RegisteredType</typeparam>
+        private class MultiInstanceFactory<RegisterType, RegisterImplementation> : ObjectFactoryBase
+            where RegisterType : class
+            where RegisterImplementation : class, RegisterType
+        {
+            public override Type CreatesType { get { return typeof(RegisterImplementation); } }
+
+            public MultiInstanceFactory()
+            {
+                if (typeof(RegisterImplementation).IsAbstract || typeof(RegisterImplementation).IsInterface)
+                    throw new TinyIoCRegistrationTypeException(typeof(RegisterImplementation), "MultiInstanceFactory");
+            }
+
+            public override object GetObject(TinyIoCContainer container, NamedParameterOverloads parameters, ResolveOptions options)
+            {
+                try
+                {
+                    return container.ConstructType(typeof(RegisterImplementation), Constructor, parameters, options);
+                }
+                catch (TinyIoCResolutionException ex)
+                {
+                    throw new TinyIoCResolutionException(typeof(RegisterImplementation), ex);
+                }
+            }
+
+            public override ObjectFactoryBase SingletonVariant
+            {
+                get
+                {
+                    return new SingletonFactory<RegisterType, RegisterImplementation>();
+                }
+            }
+
+            public override ObjectFactoryBase MultiInstanceVariant
+            {
+                get
+                {
+                    return this;
+                }
+            }
+        }
+
+        /// <summary>
+        /// IObjectFactory that invokes a specified delegate to construct the object
+        /// </summary>
+        /// <typeparam name="RegisterType">Registered type to be constructed</typeparam>
+        private class DelegateFactory<RegisterType> : ObjectFactoryBase
+            where RegisterType : class
+        {
+            private Func<TinyIoCContainer, NamedParameterOverloads, RegisterType> _factory;
+
+            public override bool AssumeConstruction { get { return true; } }
+
+            public override Type CreatesType { get { return typeof(RegisterType); } }
+
+            public override object GetObject(TinyIoCContainer container, NamedParameterOverloads parameters, ResolveOptions options)
+            {
+                try
+                {
+                    return _factory.Invoke(container, parameters);
+                }
+                catch (Exception ex)
+                {
+                    throw new TinyIoCResolutionException(typeof(RegisterType), ex);
+                }
+            }
+
+            public DelegateFactory(Func<TinyIoCContainer, NamedParameterOverloads, RegisterType> factory)
+            {
+                if (factory == null)
+                    throw new ArgumentNullException("factory");
+
+                _factory = factory;
+            }
+
+            public override ObjectFactoryBase WeakReferenceVariant
+            {
+                get
+                {
+                    return new WeakDelegateFactory<RegisterType>(_factory);
+                }
+            }
+
+            public override ObjectFactoryBase StrongReferenceVariant
+            {
+                get
+                {
+                    return this;
+                }
+            }
+
+            public override void SetConstructor(ConstructorInfo constructor)
+            {
+                throw new TinyIoCConstructorResolutionException("Constructor selection is not possible for delegate factory registrations");
+            }
+        }
+
+        /// <summary>
+        /// IObjectFactory that invokes a specified delegate to construct the object
+        /// 
+        /// Holds the delegate using a weak reference
+        /// </summary>
+        /// <typeparam name="RegisterType">Registered type to be constructed</typeparam>
+        private class WeakDelegateFactory<RegisterType> : ObjectFactoryBase
+            where RegisterType : class
+        {
+            private WeakReference _factory;
+
+            public override bool AssumeConstruction { get { return true; } }
+
+            public override Type CreatesType { get { return typeof(RegisterType); } }
+
+            public override object GetObject(TinyIoCContainer container, NamedParameterOverloads parameters, ResolveOptions options)
+            {
+                var factory = _factory.Target as Func<TinyIoCContainer, NamedParameterOverloads, RegisterType>;
+
+                if (factory == null)
+                    throw new TinyIoCWeakReferenceException(typeof(RegisterType));
+
+                try
+                {
+                    return factory.Invoke(container, parameters);
+                }
+                catch (Exception ex)
+                {
+                    throw new TinyIoCResolutionException(typeof(RegisterType), ex);
+                }
+            }
+
+            public WeakDelegateFactory(Func<TinyIoCContainer, NamedParameterOverloads, RegisterType> factory)
+            {
+                if (factory == null)
+                    throw new ArgumentNullException("factory");
+
+                _factory = new WeakReference(factory);
+            }
+
+            public override ObjectFactoryBase StrongReferenceVariant
+            {
+                get
+                {
+                    var factory = _factory.Target as Func<TinyIoCContainer, NamedParameterOverloads, RegisterType>;
+
+                    if (factory == null)
+                        throw new TinyIoCWeakReferenceException(typeof(RegisterType));
+
+                    return new DelegateFactory<RegisterType>(factory);
+                }
+            }
+
+            public override ObjectFactoryBase WeakReferenceVariant
+            {
+                get
+                {
+                    return this;
+                }
+            }
+
+            public override void SetConstructor(ConstructorInfo constructor)
+            {
+                throw new TinyIoCConstructorResolutionException("Constructor selection is not possible for delegate factory registrations");
+            }
+        }
+
+        /// <summary>
+        /// Stores an particular instance to return for a type
+        /// </summary>
+        /// <typeparam name="RegisterType">Registered type</typeparam>
+        /// <typeparam name="RegisterImplementation">Type of the instance</typeparam>
+        private class InstanceFactory<RegisterType, RegisterImplementation> : ObjectFactoryBase, IDisposable
+            where RegisterType : class
+            where RegisterImplementation : class, RegisterType
+        {
+            private RegisterImplementation _instance;
+
+            public override bool AssumeConstruction { get { return true; } }
+
+            public InstanceFactory(RegisterImplementation instance)
+            {
+                this._instance = instance;
+            }
+
+            public override Type CreatesType
+            {
+                get { return typeof(RegisterImplementation); }
+            }
+
+            public override object GetObject(TinyIoCContainer container, NamedParameterOverloads parameters, ResolveOptions options)
+            {
+                return _instance;
+            }
+
+            public override ObjectFactoryBase MultiInstanceVariant
+            {
+                get
+                {
+                    return new MultiInstanceFactory<RegisterType, RegisterImplementation>();
+                }
+            }
+
+            public override ObjectFactoryBase WeakReferenceVariant
+            {
+                get
+                {
+                    return new WeakInstanceFactory<RegisterType, RegisterImplementation>(_instance);
+                }
+            }
+
+            public override ObjectFactoryBase StrongReferenceVariant
+            {
+                get
+                {
+                    return this;
+                }
+            }
+
+            public override void SetConstructor(ConstructorInfo constructor)
+            {
+                throw new TinyIoCConstructorResolutionException("Constructor selection is not possible for instance factory registrations");
+            }
+
+            public void Dispose()
+            {
+                var disposable = _instance as IDisposable;
+
+                if (disposable != null)
+                    disposable.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Stores an particular instance to return for a type
+        /// 
+        /// Stores the instance with a weak reference
+        /// </summary>
+        /// <typeparam name="RegisterType">Registered type</typeparam>
+        /// <typeparam name="RegisterImplementation">Type of the instance</typeparam>
+        private class WeakInstanceFactory<RegisterType, RegisterImplementation> : ObjectFactoryBase, IDisposable
+            where RegisterType : class
+            where RegisterImplementation : class, RegisterType
+        {
+            private WeakReference _instance;
+
+            public WeakInstanceFactory(RegisterImplementation instance)
+            {
+                this._instance = new WeakReference(instance);
+            }
+
+            public override Type CreatesType
+            {
+                get { return typeof(RegisterImplementation); }
+            }
+
+            public override object GetObject(TinyIoCContainer container, NamedParameterOverloads parameters, ResolveOptions options)
+            {
+                var instance = _instance.Target as RegisterImplementation;
+
+                if (instance == null)
+                    throw new TinyIoCWeakReferenceException(typeof(RegisterType));
+
+                return instance;
+            }
+
+            public override ObjectFactoryBase MultiInstanceVariant
+            {
+                get
+                {
+                    return new MultiInstanceFactory<RegisterType, RegisterImplementation>();
+                }
+            }
+
+            public override ObjectFactoryBase WeakReferenceVariant
+            {
+                get
+                {
+                    return this;
+                }
+            }
+
+            public override ObjectFactoryBase StrongReferenceVariant
+            {
+                get
+                {
+                    var instance = _instance.Target as RegisterImplementation;
+
+                    if (instance == null)
+                        throw new TinyIoCWeakReferenceException(typeof(RegisterType));
+
+                    return new InstanceFactory<RegisterType, RegisterImplementation>(instance);
+                }
+            }
+
+            public override void SetConstructor(ConstructorInfo constructor)
+            {
+                throw new TinyIoCConstructorResolutionException("Constructor selection is not possible for instance factory registrations");
+            }
+
+            public void Dispose()
+            {
+                var disposable = _instance.Target as IDisposable;
+
+                if (disposable != null)
+                    disposable.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// A factory that lazy instantiates a type and always returns the same instance
+        /// </summary>
+        /// <typeparam name="RegisterType">Registered type</typeparam>
+        /// <typeparam name="RegisterImplementation">Type to instantiate</typeparam>
+        private class SingletonFactory<RegisterType, RegisterImplementation> : ObjectFactoryBase, IDisposable
+            where RegisterType : class
+            where RegisterImplementation : class, RegisterType
+        {
+            private readonly object SingletonLock = new object();
+            private RegisterImplementation _Current;
+
+            public SingletonFactory()
+            {
+                if (typeof(RegisterImplementation).IsAbstract || typeof(RegisterImplementation).IsInterface)
+                    throw new TinyIoCRegistrationTypeException(typeof(RegisterImplementation), "SingletonFactory");
+            }
+
+            public override Type CreatesType
+            {
+                get { return typeof(RegisterImplementation); }
+            }
+
+            public override object GetObject(TinyIoCContainer container, NamedParameterOverloads parameters, ResolveOptions options)
+            {
+                if (parameters.Count != 0)
+                    throw new ArgumentException("Cannot specify parameters for singleton types");
+
+                lock (SingletonLock)
+                    if (_Current == null)
+                        _Current = container.ConstructType(typeof(RegisterImplementation), Constructor, options) as RegisterImplementation;
+
+                return _Current;
+            }
+
+            public override ObjectFactoryBase SingletonVariant
+            {
+                get
+                {
+                    return this;
+                }
+            }
+
+            public override ObjectFactoryBase MultiInstanceVariant
+            {
+                get
+                {
+                    return new MultiInstanceFactory<RegisterType, RegisterImplementation>();
+                }
+            }
+
+            public void Dispose()
+            {
+                if (_Current != null)
+                {
+                    var disposable = _Current as IDisposable;
+
+                    if (disposable != null)
+                        disposable.Dispose();
+                }
+            }
+        }
+        #endregion
+
+        #region Singleton Container
+        private static readonly TinyIoCContainer _Current = new TinyIoCContainer();
+
+        static TinyIoCContainer()
+        {
+        }
+
+        /// <summary>
+        /// Lazy created Singleton instance of the container for simple scenarios
+        /// </summary>
+        public static TinyIoCContainer Current
+        {
+            get
+            {
+                return _Current;
+            }
+        }
+        #endregion
+
+        #region Type Registrations
+        public sealed class TypeRegistration
+        {
+            public Type Type { get; private set; }
+            public string Name { get; private set; }
+
+            public TypeRegistration(Type type)
+                : this(type, string.Empty)
+            {
+            }
+
+            public TypeRegistration(Type type, string name)
+            {
+                Type = type;
+                Name = name;
+            }
+
+            public override bool Equals(object obj)
+            {
+                var typeRegistration = obj as TypeRegistration;
+
+                if (obj == null)
+                    return false;
+
+                if (this.Type != typeRegistration.Type)
+                    return false;
+
+                if (String.Compare(this.Name, typeRegistration.Name, true) != 0)
+                    return false;
+
+                return true;
+            }
+
+            public override int GetHashCode()
+            {
+                return String.Format("{0}|{1}", this.Type.FullName, this.Name).GetHashCode();
+            }
+        }
+        private readonly SafeDictionary<TypeRegistration, ObjectFactoryBase> _RegisteredTypes;
+        #endregion
+
+        #region Constructors
+        public TinyIoCContainer()
+        {
+            _RegisteredTypes = new SafeDictionary<TypeRegistration, ObjectFactoryBase>();
+
+            RegisterDefaultTypes();
+        }
+        #endregion
+
+        #region Internal Methods
+        private readonly object _AutoRegisterLock = new object();
+        private void AutoRegisterInternal(IEnumerable<Assembly> assemblies, bool ignoreDuplicateImplementations)
+        {
+            lock (_AutoRegisterLock)
+            {
+                var defaultFactoryMethod = this.GetType().GetMethod("GetDefaultObjectFactory", BindingFlags.NonPublic | BindingFlags.Instance);
+
+                var types = assemblies.SelectMany(a => a.GetTypes()).Where(t => !IsIgnoredType(t)).ToList();
+
+                var sortedTypes = types.OrderBy(o => o.Name);
+
+                var concreteTypes = from type in types
+                                    where (type.IsClass == true) && (type.IsAbstract == false) && (type != this.GetType() && (type.DeclaringType != this.GetType()) && (!type.IsGenericTypeDefinition))
+                                    select type;
+
+                foreach (var type in concreteTypes)
+                {
+                    Type[] genericTypes = { type, type };
+                    var genericDefaultFactoryMethod = defaultFactoryMethod.MakeGenericMethod(genericTypes);
+                    this.RegisterInternal(type, type, string.Empty, genericDefaultFactoryMethod.Invoke(this, null) as ObjectFactoryBase);
+                }
+
+                var abstractInterfaceTypes = from type in types
+                                             where ((type.IsInterface == true || type.IsAbstract == true) && (type.DeclaringType != this.GetType()) && (!type.IsGenericTypeDefinition))
+                                             select type;
+
+                foreach (var type in abstractInterfaceTypes)
+                {
+                    var implementations = from implementationType in concreteTypes
+                                          where implementationType.GetInterfaces().Contains(type) || implementationType.BaseType == type
+                                          select implementationType;
+
+                    if (!ignoreDuplicateImplementations && implementations.Count() > 1)
+                        throw new TinyIoCAutoRegistrationException(type, implementations);
+
+                    var firstImplementation = implementations.FirstOrDefault();
+                    if (firstImplementation != null)
+                    {
+                        Type[] genericTypes = { type, firstImplementation };
+                        var genericDefaultFactoryMethod = defaultFactoryMethod.MakeGenericMethod(genericTypes);
+                        this.RegisterInternal(type, firstImplementation, string.Empty, genericDefaultFactoryMethod.Invoke(this, null) as ObjectFactoryBase);
+                    }
+                }
+            }
+        }
+
+        private bool IsIgnoredType(Type type)
+        {
+            // TODO - find a better way to remove "system" types from the auto registration
+            if (type.FullName.StartsWith("System.") || type.FullName.StartsWith("Microsoft."))
+                return true;
+
+            if (type.IsPrimitive)
+                return true;
+
+            if ((type.GetConstructors(BindingFlags.Instance | BindingFlags.Public).Length == 0) && !(type.IsInterface || type.IsAbstract))
+                return true;
+
+            return false;
+        }
+
+        private void RegisterDefaultTypes()
+        {
+            this.Register<TinyIoCContainer>(this);
+#if TINYMESSENGER
+            if (parent == null)
+                this.Register<ITinyMessenger, TinyMessenger>();
+#endif
+        }
+
+        private ObjectFactoryBase GetCurrentFactory(TypeRegistration registration)
+        {
+            ObjectFactoryBase current = null;
+
+            _RegisteredTypes.TryGetValue(registration, out current);
+
+            return current;
+        }
+
+        private RegisterOptions RegisterInternal(Type registerType, Type registerImplementation, string name, ObjectFactoryBase factory)
+        {
+            var typeRegistration = new TypeRegistration(registerType, name);
+
+            return AddUpdateRegistration(typeRegistration, factory);
+        }
+
+        private RegisterOptions AddUpdateRegistration(TypeRegistration typeRegistration, ObjectFactoryBase factory)
+        {
+            _RegisteredTypes[typeRegistration] = factory;
+
+            return new RegisterOptions(this, typeRegistration);
+        }
+
+        private void RemoveRegistration(TypeRegistration typeRegistration)
+        {
+            _RegisteredTypes.Remove(typeRegistration);
+        }
+
+        private ObjectFactoryBase GetDefaultObjectFactory<RegisterType, RegisterImplementation>()
+            where RegisterType : class
+            where RegisterImplementation : class, RegisterType
+        {
+            if (typeof(RegisterType).IsInterface || typeof(RegisterType).IsAbstract)
+                return new SingletonFactory<RegisterType, RegisterImplementation>();
+
+            return new MultiInstanceFactory<RegisterType, RegisterImplementation>();
+        }
+
+        private bool CanResolveInternal(TypeRegistration registration, NamedParameterOverloads parameters, ResolveOptions options)
+        {
+            if (parameters == null)
+                throw new ArgumentNullException("parameters");
+
+            Type checkType = registration.Type;
+            string name = registration.Name;
+
+            ObjectFactoryBase factory;
+            if (_RegisteredTypes.TryGetValue(new TypeRegistration(checkType, name), out factory))
+            {
+                if (factory.AssumeConstruction)
+                    return true;
+
+                if (factory.Constructor == null)
+                    return (GetBestConstructor(factory.CreatesType, parameters, options) != null) ? true : false;
+                else
+                    return CanConstruct(factory.Constructor, parameters, options);
+            }
+
+            // Fail if requesting named resolution and settings set to fail if unresolved
+            if (!String.IsNullOrEmpty(name) && options.NamedResolutionFailureAction == NamedResolutionFailureActions.Fail)
+                return false;
+
+            // Attemped unnamed fallback container resolution if relevant and requested
+            if (!String.IsNullOrEmpty(name) && options.NamedResolutionFailureAction == NamedResolutionFailureActions.AttemptUnnamedResolution)
+            {
+                if (_RegisteredTypes.TryGetValue(new TypeRegistration(checkType), out factory))
+                {
+                    if (factory.AssumeConstruction)
+                        return true;
+
+                    return (GetBestConstructor(factory.CreatesType, parameters, options) != null) ? true : false;
+                }
+            }
+
+            // Check if type is an automatic lazy factory request
+            if (IsAutomaticLazyFactoryRequest(checkType))
+                return true;
+
+            // Attempt unregistered construction if possible and requested
+            if ((options.UnregisteredResolutionAction == UnregisteredResolutionActions.AttemptResolve) || (checkType.IsGenericType && options.UnregisteredResolutionAction == UnregisteredResolutionActions.GenericsOnly))
+                return (GetBestConstructor(checkType, parameters, options) != null) ? true : false;
+
+            return false;
+        }
+
+        private bool IsAutomaticLazyFactoryRequest(Type type)
+        {
+            if (!type.IsGenericType)
+                return false;
+
+            Type genericType = type.GetGenericTypeDefinition();
+
+            // Just a func
+            if (genericType == typeof(Func<>))
+                return true;
+
+            // 2 parameter func with string as first parameter (name)
+            if ((genericType == typeof(Func<,>) && type.GetGenericArguments()[0] == typeof(string)))
+                return true;
+
+            // 3 parameter func with string as first parameter (name) and IDictionary<string, object> as second (parameters)
+            if ((genericType == typeof(Func<,,>) && type.GetGenericArguments()[0] == typeof(string) && type.GetGenericArguments()[1] == typeof(IDictionary<String, object>)))
+                return true;
+
+            return false;
+        }
+
+        private object ResolveInternal(TypeRegistration registration, NamedParameterOverloads parameters, ResolveOptions options)
+        {
+            ObjectFactoryBase factory;
+
+            // Attempt container resolution
+            if (_RegisteredTypes.TryGetValue(registration, out factory))
+            {
+                try
+                {
+                    return factory.GetObject(this, parameters, options);
+                }
+                catch (Exception ex)
+                {
+                    throw new TinyIoCResolutionException(registration.Type, ex);
+                }
+            }
+
+            // Fail if requesting named resolution and settings set to fail if unresolved
+            if (!String.IsNullOrEmpty(registration.Name) && options.NamedResolutionFailureAction == NamedResolutionFailureActions.Fail)
+                throw new TinyIoCResolutionException(registration.Type);
+
+            // Attemped unnamed fallback container resolution if relevant and requested
+            if (!String.IsNullOrEmpty(registration.Name) && options.NamedResolutionFailureAction == NamedResolutionFailureActions.AttemptUnnamedResolution)
+            {
+                if (_RegisteredTypes.TryGetValue(new TypeRegistration(registration.Type, string.Empty), out factory))
+                {
+                    try
+                    {
+                        return factory.GetObject(this, parameters, options);
+                    }
+                    catch (Exception ex)
+                    {
+                        throw new TinyIoCResolutionException(registration.Type, ex);
+                    }
+                }
+            }
+
+            // Attempt to construct an automatic lazy factory if possible
+            if (IsAutomaticLazyFactoryRequest(registration.Type))
+                return GetLazyAutomaticFactoryRequest(registration.Type);
+
+            // Attempt unregistered construction if possible and requested
+            if ((options.UnregisteredResolutionAction == UnregisteredResolutionActions.AttemptResolve) || (registration.Type.IsGenericType && options.UnregisteredResolutionAction == UnregisteredResolutionActions.GenericsOnly))
+            {
+                if (!registration.Type.IsAbstract && !registration.Type.IsInterface)
+                    return ConstructType(registration.Type, parameters, options);
+            }
+
+            // Unable to resolve - throw
+            throw new TinyIoCResolutionException(registration.Type);
+        }
+
+        private object GetLazyAutomaticFactoryRequest(Type type)
+        {
+            if (!type.IsGenericType)
+                return null;
+
+            Type genericType = type.GetGenericTypeDefinition();
+            Type[] genericArguments = type.GetGenericArguments();
+
+            // Just a func
+            if (genericType == typeof(Func<>))
+            {
+                Type returnType = genericArguments[0];
+
+                MethodInfo resolveMethod = typeof(TinyIoCContainer).GetMethod("Resolve", new Type[] { });
+                resolveMethod = resolveMethod.MakeGenericMethod(returnType);
+
+                var resolveCall = Expression.Call(Expression.Constant(this), resolveMethod);
+
+                var resolveLambda = Expression.Lambda(resolveCall).Compile();
+
+                return resolveLambda;
+            }
+
+            // 2 parameter func with string as first parameter (name)
+            if ((genericType == typeof(Func<,>)) && (genericArguments[0] == typeof(string)))
+            {
+                Type returnType = genericArguments[1];
+
+                MethodInfo resolveMethod = typeof(TinyIoCContainer).GetMethod("Resolve", new Type[] { typeof(String) });
+                resolveMethod = resolveMethod.MakeGenericMethod(returnType);
+
+                ParameterExpression[] resolveParameters = new ParameterExpression[] { Expression.Parameter(typeof(String), "name") };
+                var resolveCall = Expression.Call(Expression.Constant(this), resolveMethod, resolveParameters);
+
+                var resolveLambda = Expression.Lambda(resolveCall, resolveParameters).Compile();
+
+                return resolveLambda;
+            }
+
+            // 3 parameter func with string as first parameter (name) and IDictionary<string, object> as second (parameters)
+            if ((genericType == typeof(Func<,,>) && type.GetGenericArguments()[0] == typeof(string) && type.GetGenericArguments()[1] == typeof(IDictionary<string, object>)))
+            {
+                Type returnType = genericArguments[2];
+
+                var name = Expression.Parameter(typeof(string), "name");
+                var parameters = Expression.Parameter(typeof(IDictionary<string, object>), "parameters");
+
+                MethodInfo resolveMethod = typeof(TinyIoCContainer).GetMethod("Resolve", new Type[] { typeof(String), typeof(NamedParameterOverloads) });
+                resolveMethod = resolveMethod.MakeGenericMethod(returnType);
+
+                var resolveCall = Expression.Call(Expression.Constant(this), resolveMethod, name, Expression.Call(typeof(NamedParameterOverloads), "FromIDictionary", null, parameters));
+
+                var resolveLambda = Expression.Lambda(resolveCall, name, parameters).Compile();
+
+                return resolveLambda;
+            }
+
+            throw new TinyIoCResolutionException(type);
+        }
+
+        private bool CanConstruct(ConstructorInfo ctor, NamedParameterOverloads parameters, ResolveOptions options)
+        {
+            if (parameters == null)
+                throw new ArgumentNullException("parameters");
+
+            foreach (var parameter in ctor.GetParameters())
+            {
+                if (string.IsNullOrEmpty(parameter.Name))
+                    return false;
+
+                var isParameterOverload = parameters.ContainsKey(parameter.Name);
+
+                if (parameter.ParameterType.IsPrimitive && !isParameterOverload)
+                    return false;
+
+                if (!isParameterOverload && !CanResolveInternal(new TypeRegistration(parameter.ParameterType), NamedParameterOverloads.Default, options))
+                    return false;
+            }
+
+            return true;
+        }
+
+        private ConstructorInfo GetBestConstructor(Type type, NamedParameterOverloads parameters, ResolveOptions options)
+        {
+            if (parameters == null)
+                throw new ArgumentNullException("parameters");
+
+            if (type.IsValueType)
+                return null;
+
+            // Get constructors in reverse order based on the number of parameters
+            // i.e. be as "greedy" as possible so we satify the most amount of dependencies possible
+            var ctors = from ctor in type.GetConstructors()
+                        orderby ctor.GetParameters().Count() descending
+                        select ctor;
+
+            foreach (var ctor in ctors)
+            {
+                if (CanConstruct(ctor, parameters, options))
+                    return ctor;
+            }
+
+            return null;
+        }
+
+        private object ConstructType(Type type, ResolveOptions options)
+        {
+            return ConstructType(type, null, NamedParameterOverloads.Default, options);
+        }
+
+        private object ConstructType(Type type, ConstructorInfo constructor, ResolveOptions options)
+        {
+            return ConstructType(type, constructor, NamedParameterOverloads.Default, options);
+        }
+
+        private object ConstructType(Type type, NamedParameterOverloads parameters, ResolveOptions options)
+        {
+            return ConstructType(type, null, parameters, options);
+        }
+
+        private object ConstructType(Type type, ConstructorInfo constructor, NamedParameterOverloads parameters, ResolveOptions options)
+        {
+            if (constructor == null)
+                constructor = GetBestConstructor(type, parameters, options);
+
+            if (constructor == null)
+                throw new TinyIoCResolutionException(type);
+
+            var ctorParams = constructor.GetParameters();
+            object[] args = new object[ctorParams.Count()];
+
+            for (int parameterIndex = 0; parameterIndex < ctorParams.Count(); parameterIndex++)
+            {
+                var currentParam = ctorParams[parameterIndex];
+
+                args[parameterIndex] = parameters.ContainsKey(currentParam.Name) ? parameters[currentParam.Name] : ResolveInternal(new TypeRegistration(currentParam.ParameterType), NamedParameterOverloads.Default, options);
+            }
+
+            try
+            {
+                return constructor.Invoke(args);
+            }
+            catch (Exception ex)
+            {
+                throw new TinyIoCResolutionException(type, ex);
+            }
+        }
+
+        private void BuildUpInternal(object input, ResolveOptions resolveOptions)
+        {
+            var properties = from property in input.GetType().GetProperties()
+                             where (property.GetGetMethod() != null) && (property.GetSetMethod() != null) && !property.PropertyType.IsValueType
+                             select property;
+
+            foreach (var property in properties)
+            {
+                if (property.GetValue(input, null) == null)
+                {
+                    try
+                    {
+                        property.SetValue(input, ResolveInternal(new TypeRegistration(property.PropertyType), NamedParameterOverloads.Default, resolveOptions), null);
+                    }
+                    catch (Exception TinyIoCResolutionException)
+                    {
+                        // Catch any resolution errors and ignore them
+                    }
+                }
+            }
+        }
+        #endregion
+
+        #region IDisposable Members
+        public void Dispose()
+        {
+            _RegisteredTypes.Dispose();
+        }
+
+        #endregion
+    }
+}
diff -r 0b294eb35ad2b5d59594af0aedfa39a80eec7f58 -r efb2e93c1d9cfea3cdfb5ae96b0b2ad6a2ec9c55 TinyIoC/TinyIoC.csproj
--- a/TinyIoC/TinyIoC.csproj	Thu Mar 11 17:26:31 2010 +0000
+++ b/TinyIoC/TinyIoC.csproj	Sun Mar 14 19:00:54 2010 +0000
@@ -47,6 +47,7 @@
   <ItemGroup>
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="TinyIoC.cs" />
+    <Compile Include="TinyMessenger.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff -r 0b294eb35ad2b5d59594af0aedfa39a80eec7f58 -r efb2e93c1d9cfea3cdfb5ae96b0b2ad6a2ec9c55 TinyIoC/TinyMessenger.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TinyIoC/TinyMessenger.cs	Sun Mar 14 19:00:54 2010 +0000
@@ -0,0 +1,758 @@
+//===============================================================================
+// TinyIoC - TinyMessenger
+//
+// A simple messenger/event aggregator.
+//
+// http://hg.grumpydev.com/tinyioc
+//===============================================================================
+// Copyright © Steven Robbins.  All rights reserved.
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT
+// LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+// FITNESS FOR A PARTICULAR PURPOSE.
+//===============================================================================
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TinyMessenger
+{
+    #region Message Types / Interfaces
+    /// <summary>
+    /// A TinyMessage to be published/delivered by TinyMessenger
+    /// </summary>
+    public interface ITinyMessage
+    {
+        /// <summary>
+        /// The sender of the message, or null if not supported by the message implementation.
+        /// </summary>
+        object Sender { get; }
+    }
+
+    /// <summary>
+    /// Base class for messages that provides weak refrence storage of the sender
+    /// </summary>
+    public abstract class TinyMessageBase : ITinyMessage
+    {
+        /// <summary>
+        /// Store a WeakReference to the sender just in case anyone is daft enough to
+        /// keep the message around and prevent the sender from being collected.
+        /// </summary>
+        private WeakReference _Sender;
+        public object Sender
+        {
+            get
+            {
+                return (_Sender == null) ? null : _Sender.Target;
+            }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the MessageBase class.
+        /// </summary>
+        /// <param name="sender">Message sender (usually "this")</param>
+        public TinyMessageBase(object sender)
+        {
+            if (sender == null)
+                throw new ArgumentNullException("sender");
+
+            _Sender = new WeakReference(sender);
+        }
+    }
+
+    /// <summary>
+    /// Generic message with user specified content
+    /// </summary>
+    /// <typeparam name="TContent">Content type to store</typeparam>
+    public class GenericTinyMessage<TContent> : TinyMessageBase
+    {
+        /// <summary>
+        /// Contents of the message
+        /// </summary>
+        public TContent Content { get; protected set; }
+
+        /// <summary>
+        /// Create a new instance of the GenericTinyMessage class.
+        /// </summary>
+        /// <param name="sender">Message sender (usually "this")</param>
+        /// <param name="content">Contents of the message</param>
+        public GenericTinyMessage(object sender, TContent content)
+            : base(sender)
+        {
+            Content = content;
+        }
+    }
+
+    /// <summary>
+    /// Basic "cancellable" generic message
+    /// </summary>
+    /// <typeparam name="TContent">Content type to store</typeparam>
+    public class CancellableGenericTinyMessage<TContent> : TinyMessageBase
+    {
+        /// <summary>
+        /// Cancel action
+        /// </summary>
+        public Action Cancel { get; protected set; }
+
+        /// <summary>
+        /// Contents of the message
+        /// </summary>
+        public TContent Content { get; protected set; }
+
+        /// <summary>
+        /// Create a new instance of the CancellableGenericTinyMessage class.
+        /// </summary>
+        /// <param name="sender">Message sender (usually "this")</param>
+        /// <param name="content">Contents of the message</param>
+        /// <param name="cancelAction">Action to call for cancellation</param>
+        public CancellableGenericTinyMessage(object sender, TContent content, Action cancelAction)
+            : base(sender)
+        {
+            if (cancelAction == null)
+                throw new ArgumentNullException("cancelAction");
+
+            Content = content;
+            Cancel = cancelAction;
+        }
+    }
+
+    /// <summary>
+    /// Represents an active subscription to a message
+    /// </summary>
+    public sealed class TinyMessageSubscriptionToken
+    {
+    }
+
+    /// <summary>
+    /// Represents a message subscription
+    /// </summary>
+    public interface ITinyMessageSubscription
+    {
+        /// <summary>
+        /// Token returned to the subscribed to reference this subscription
+        /// </summary>
+        TinyMessageSubscriptionToken SubscriptionToken { get; }
+
+        /// <summary>
+        /// Whether delivery should be attempted.
+        /// </summary>
+        /// <param name="message">Message that may potentially be delivered.</param>
+        /// <returns>True - ok to send, False - should not attempt to send</returns>
+        bool ShouldAttemptDelivery(ITinyMessage message);
+
+        /// <summary>
+        /// Deliver the message
+        /// </summary>
+        /// <param name="message">Message to deliver</param>
+        void Deliver(ITinyMessage message);
+    }
+
+    /// <summary>
+    /// Message proxy definition.
+    /// 
+    /// A message proxy can be used to intercept/alter messages and/or
+    /// marshall delivery actions onto a particular thread.
+    /// </summary>
+    public interface ITinyMessageProxy
+    {
+        void Deliver(ITinyMessage message, ITinyMessageSubscription subscription);
+    }
+
+    /// <summary>
+    /// Default "pass through" proxy.
+    /// 
+    /// Does nothing other than deliver the message.
+    /// </summary>
+    public sealed class DefaultTinyMessageProxy : ITinyMessageProxy
+    {
+        private static readonly DefaultTinyMessageProxy _Instance = new DefaultTinyMessageProxy();
+
+        static DefaultTinyMessageProxy()
+        {
+        }
+
+        /// <summary>
+        /// Singleton instance of the proxy.
+        /// </summary>
+        public static DefaultTinyMessageProxy Instance
+        {
+            get
+            {
+                return _Instance;
+            }
+        }
+
+        private DefaultTinyMessageProxy()
+        {
+        }
+
+        public void Deliver(ITinyMessage message, ITinyMessageSubscription subscription)
+        {
+            subscription.Deliver(message);
+        }
+    }
+    #endregion
+
+    #region Exceptions
+    /// <summary>
+    /// Thrown when an exceptions occurs while subscribing to a message type
+    /// </summary>
+    public class TinyMessengerSubscriptionException : Exception
+    {
+        private const string ERROR_TEXT = "Unable to add subscription for {0} : {1}";
+
+        public TinyMessengerSubscriptionException(Type messageType, string reason)
+            : base(String.Format(ERROR_TEXT, messageType, reason))
+        {
+
+        }
+
+        public TinyMessengerSubscriptionException(Type messageType, string reason, Exception innerException)
+            : base(String.Format(ERROR_TEXT, messageType, reason), innerException)
+        {
+
+        }
+    }
+    #endregion
+
+    #region Hub Interface
+    /// <summary>
+    /// Messenger hub responsible for taking subscriptions/publications and delivering of messages.
+    /// </summary>
+    public interface ITinyMessengerHub
+    {
+        /// <summary>
+        /// Subscribe to a message type with the given destination and delivery action.
+        /// All references are held with WeakReferences
+        /// 
+        /// All messages of this type will be delivered.
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="deliveryAction">Action to invoke when message is delivered</param>
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        TinyMessageSubscriptionToken Subscribe<TMessage>(Action<TMessage> deliveryAction) where TMessage : class, ITinyMessage;
+
+        /// <summary>
+        /// Subscribe to a message type with the given destination and delivery action.
+        /// Messages will be delivered via the specified proxy.
+        /// All references (apart from the proxy) are held with WeakReferences
+        /// 
+        /// All messages of this type will be delivered.
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="deliveryAction">Action to invoke when message is delivered</param>
+        /// <param name="proxy">Proxy to use when delivering the messages</param>
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        TinyMessageSubscriptionToken Subscribe<TMessage>(Action<TMessage> deliveryAction, ITinyMessageProxy proxy) where TMessage : class, ITinyMessage;
+
+        /// <summary>
+        /// Subscribe to a message type with the given destination and delivery action.
+        /// 
+        /// All messages of this type will be delivered.
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="deliveryAction">Action to invoke when message is delivered</param>
+        /// <param name="useStrongReferences">Use strong references to destination and deliveryAction </param>
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        TinyMessageSubscriptionToken Subscribe<TMessage>(Action<TMessage> deliveryAction, bool useStrongReferences) where TMessage : class, ITinyMessage;
+
+        /// <summary>
+        /// Subscribe to a message type with the given destination and delivery action.
+        /// Messages will be delivered via the specified proxy.
+        /// 
+        /// All messages of this type will be delivered.
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="deliveryAction">Action to invoke when message is delivered</param>
+        /// <param name="useStrongReferences">Use strong references to destination and deliveryAction </param>
+        /// <param name="proxy">Proxy to use when delivering the messages</param>
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        TinyMessageSubscriptionToken Subscribe<TMessage>(Action<TMessage> deliveryAction, bool useStrongReferences, ITinyMessageProxy proxy) where TMessage : class, ITinyMessage;
+
+        /// <summary>
+        /// Subscribe to a message type with the given destination and delivery action with the given filter.
+        /// All references are held with WeakReferences
+        /// 
+        /// Only messages that "pass" the filter will be delivered.
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="deliveryAction">Action to invoke when message is delivered</param>
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        TinyMessageSubscriptionToken Subscribe<TMessage>(Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter) where TMessage : class, ITinyMessage;
+
+        /// <summary>
+        /// Subscribe to a message type with the given destination and delivery action with the given filter.
+        /// Messages will be delivered via the specified proxy.
+        /// All references (apart from the proxy) are held with WeakReferences
+        /// 
+        /// Only messages that "pass" the filter will be delivered.
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="deliveryAction">Action to invoke when message is delivered</param>
+        /// <param name="proxy">Proxy to use when delivering the messages</param>
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        TinyMessageSubscriptionToken Subscribe<TMessage>(Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter, ITinyMessageProxy proxy) where TMessage : class, ITinyMessage;
+
+        /// <summary>
+        /// Subscribe to a message type with the given destination and delivery action with the given filter.
+        /// All references are held with WeakReferences
+        /// 
+        /// Only messages that "pass" the filter will be delivered.
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="deliveryAction">Action to invoke when message is delivered</param>
+        /// <param name="useStrongReferences">Use strong references to destination and deliveryAction </param>
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        TinyMessageSubscriptionToken Subscribe<TMessage>(Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter, bool useStrongReferences) where TMessage : class, ITinyMessage;
+
+        /// <summary>
+        /// Subscribe to a message type with the given destination and delivery action with the given filter.
+        /// Messages will be delivered via the specified proxy.
+        /// All references are held with WeakReferences
+        /// 
+        /// Only messages that "pass" the filter will be delivered.
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="deliveryAction">Action to invoke when message is delivered</param>
+        /// <param name="useStrongReferences">Use strong references to destination and deliveryAction </param>
+        /// <param name="proxy">Proxy to use when delivering the messages</param>
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        TinyMessageSubscriptionToken Subscribe<TMessage>(Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter, bool useStrongReferences, ITinyMessageProxy proxy) where TMessage : class, ITinyMessage;
+
+        /// <summary>
+        /// Unsubscribe from a particular message type.
+        /// 
+        /// Does not throw an exception if the subscription is not found.
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="subscriptionToken">Subscription token received from Subscribe</param>
+        void Unsubscribe<TMessage>(TinyMessageSubscriptionToken subscriptionToken) where TMessage : class, ITinyMessage;
+
+        /// <summary>
+        /// Publish a message to any subscribers
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="message">Message to deliver</param>
+        void Publish<TMessage>(TMessage message) where TMessage : class, ITinyMessage;
+
+        /// <summary>
+        /// Publish a message to any subscribers asynchronously
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="message">Message to deliver</param>
+        void PublishAsync<TMessage>(TMessage message) where TMessage : class, ITinyMessage;
+
+        /// <summary>
+        /// Publish a message to any subscribers asynchronously
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="message">Message to deliver</param>
+        /// <param name="callback">AsyncCallback called on completion</param>
+        void PublishAsync<TMessage>(TMessage message, AsyncCallback callback) where TMessage : class, ITinyMessage;
+    }
+    #endregion
+
+    #region Hub Implementation
+    /// <summary>
+    /// Messenger hub responsible for taking subscriptions/publications and delivering of messages.
+    /// </summary>
+    public sealed class TinyMessengerHub : ITinyMessengerHub
+    {
+        #region Private Types and Interfaces
+        private class WeakTinyMessageSubscription<TMessage> : ITinyMessageSubscription
+            where TMessage : class, ITinyMessage
+        {
+            protected TinyMessageSubscriptionToken _SubscriptionToken;
+            protected WeakReference _DeliveryAction;
+            protected WeakReference _MessageFilter;
+
+            public TinyMessageSubscriptionToken SubscriptionToken
+            {
+                get { return _SubscriptionToken; }
+            }
+
+            public bool ShouldAttemptDelivery(ITinyMessage message)
+            {
+                if (!(message is TMessage))
+                    return false;
+
+                if (!_DeliveryAction.IsAlive)
+                    return false;
+
+                if (!_MessageFilter.IsAlive)
+                    return false;
+
+                return ((Func<TMessage, bool>)_MessageFilter.Target).Invoke(message as TMessage);
+            }
+
+            public void Deliver(ITinyMessage message)
+            {
+                if (!(message is TMessage))
+                    throw new ArgumentException("Message is not the correct type");
+
+                if (!_DeliveryAction.IsAlive)
+                    return;
+
+                ((Action<TMessage>)_DeliveryAction.Target).Invoke(message as TMessage);
+            }
+
+            /// <summary>
+            /// Initializes a new instance of the WeakTinyMessageSubscription class.
+            /// </summary>
+            /// <param name="destination">Destination object</param>
+            /// <param name="deliveryAction">Delivery action</param>
+            /// <param name="messageFilter">Filter function</param>
+            public WeakTinyMessageSubscription(TinyMessageSubscriptionToken subscriptionToken, Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter)
+            {
+                if (subscriptionToken == null)
+                    throw new ArgumentNullException("subscriptionToken");
+
+                if (deliveryAction == null)
+                    throw new ArgumentNullException("deliveryAction");
+
+                if (messageFilter == null)
+                    throw new ArgumentNullException("messageFilter");
+
+                _SubscriptionToken = subscriptionToken;
+                _DeliveryAction = new WeakReference(deliveryAction);
+                _MessageFilter = new WeakReference(messageFilter);
+            }
+        }
+
+        private class StrongTinyMessageSubscription<TMessage> : ITinyMessageSubscription
+            where TMessage : class, ITinyMessage
+        {
+            protected TinyMessageSubscriptionToken _SubscriptionToken;
+            protected Action<TMessage> _DeliveryAction;
+            protected Func<TMessage, bool> _MessageFilter;
+
+            public TinyMessageSubscriptionToken SubscriptionToken
+            {
+                get { return _SubscriptionToken; }
+            }
+
+            public bool ShouldAttemptDelivery(ITinyMessage message)
+            {
+                if (!(message is TMessage))
+                    return false;
+
+                return _MessageFilter.Invoke(message as TMessage);
+            }
+
+            public void Deliver(ITinyMessage message)
+            {
+                if (!(message is TMessage))
+                    throw new ArgumentException("Message is not the correct type");
+
+                _DeliveryAction.Invoke(message as TMessage);
+            }
+
+            /// <summary>
+            /// Initializes a new instance of the TinyMessageSubscription class.
+            /// </summary>
+            /// <param name="destination">Destination object</param>
+            /// <param name="deliveryAction">Delivery action</param>
+            /// <param name="messageFilter">Filter function</param>
+            public StrongTinyMessageSubscription(TinyMessageSubscriptionToken subscriptionToken, Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter)
+            {
+                if (subscriptionToken == null)
+                    throw new ArgumentNullException("subscriptionToken");
+
+                if (deliveryAction == null)
+                    throw new ArgumentNullException("deliveryAction");
+
+                if (messageFilter == null)
+                    throw new ArgumentNullException("messageFilter");
+
+                _SubscriptionToken = subscriptionToken;
+                _DeliveryAction = deliveryAction;
+                _MessageFilter = messageFilter;
+            }
+        }
+        #endregion
+
+        #region Subscription dictionary
+        private class SubscriptionItem
+        {
+            public ITinyMessageProxy Proxy { get; private set; }
+            public ITinyMessageSubscription Subscription { get; private set; }
+
+            public SubscriptionItem(ITinyMessageProxy proxy, ITinyMessageSubscription subscription)
+            {
+                Proxy = proxy;
+                Subscription = subscription;
+            }
+        }
+
+        private readonly object _SubscriptionsPadlock = new object();
+        private readonly Dictionary<Type, List<SubscriptionItem>> _Subscriptions = new Dictionary<Type, List<SubscriptionItem>>();
+        #endregion
+
+        #region Public API
+        /// <summary>
+        /// Subscribe to a message type with the given destination and delivery action.
+        /// All references are held with WeakReferences
+        /// 
+        /// All messages of this type will be delivered.
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="deliveryAction">Action to invoke when message is delivered</param>
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        public TinyMessageSubscriptionToken Subscribe<TMessage>(Action<TMessage> deliveryAction) where TMessage : class, ITinyMessage
+        {
+            return AddSubscriptionInternal<TMessage>(deliveryAction, (m) => true, false, DefaultTinyMessageProxy.Instance);
+        }
+
+        /// <summary>
+        /// Subscribe to a message type with the given destination and delivery action.
+        /// Messages will be delivered via the specified proxy.
+        /// All references (apart from the proxy) are held with WeakReferences
+        /// 
+        /// All messages of this type will be delivered.
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="deliveryAction">Action to invoke when message is delivered</param>
+        /// <param name="proxy">Proxy to use when delivering the messages</param>
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        public TinyMessageSubscriptionToken Subscribe<TMessage>(Action<TMessage> deliveryAction, ITinyMessageProxy proxy) where TMessage : class, ITinyMessage
+        {
+            return AddSubscriptionInternal<TMessage>(deliveryAction, (m) => true, false, proxy);
+        }
+
+        /// <summary>
+        /// Subscribe to a message type with the given destination and delivery action.
+        /// 
+        /// All messages of this type will be delivered.
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="deliveryAction">Action to invoke when message is delivered</param>
+        /// <param name="useStrongReferences">Use strong references to destination and deliveryAction </param>
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        public TinyMessageSubscriptionToken Subscribe<TMessage>(Action<TMessage> deliveryAction, bool useStrongReferences) where TMessage : class, ITinyMessage
+        {
+            return AddSubscriptionInternal<TMessage>(deliveryAction, (m) => true, useStrongReferences, DefaultTinyMessageProxy.Instance);
+        }
+
+        /// <summary>
+        /// Subscribe to a message type with the given destination and delivery action.
+        /// Messages will be delivered via the specified proxy.
+        /// 
+        /// All messages of this type will be delivered.
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="deliveryAction">Action to invoke when message is delivered</param>
+        /// <param name="useStrongReferences">Use strong references to destination and deliveryAction </param>
+        /// <param name="proxy">Proxy to use when delivering the messages</param>
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        public TinyMessageSubscriptionToken Subscribe<TMessage>(Action<TMessage> deliveryAction, bool useStrongReferences, ITinyMessageProxy proxy) where TMessage : class, ITinyMessage
+        {
+            return AddSubscriptionInternal<TMessage>(deliveryAction, (m) => true, useStrongReferences, proxy);
+        }
+
+        /// <summary>
+        /// Subscribe to a message type with the given destination and delivery action with the given filter.
+        /// All references are held with WeakReferences
+        /// 
+        /// Only messages that "pass" the filter will be delivered.
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="deliveryAction">Action to invoke when message is delivered</param>
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        public TinyMessageSubscriptionToken Subscribe<TMessage>(Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter) where TMessage : class, ITinyMessage
+        {
+            return AddSubscriptionInternal<TMessage>(deliveryAction, messageFilter, false, DefaultTinyMessageProxy.Instance);
+        }
+
+        /// <summary>
+        /// Subscribe to a message type with the given destination and delivery action with the given filter.
+        /// Messages will be delivered via the specified proxy.
+        /// All references (apart from the proxy) are held with WeakReferences
+        /// 
+        /// Only messages that "pass" the filter will be delivered.
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="deliveryAction">Action to invoke when message is delivered</param>
+        /// <param name="proxy">Proxy to use when delivering the messages</param>
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        public TinyMessageSubscriptionToken Subscribe<TMessage>(Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter, ITinyMessageProxy proxy) where TMessage : class, ITinyMessage
+        {
+            return AddSubscriptionInternal<TMessage>(deliveryAction, messageFilter, false, proxy);
+        }
+
+        /// <summary>
+        /// Subscribe to a message type with the given destination and delivery action with the given filter.
+        /// All references are held with WeakReferences
+        /// 
+        /// Only messages that "pass" the filter will be delivered.
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="deliveryAction">Action to invoke when message is delivered</param>
+        /// <param name="useStrongReferences">Use strong references to destination and deliveryAction </param>
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        public TinyMessageSubscriptionToken Subscribe<TMessage>(Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter, bool useStrongReferences) where TMessage : class, ITinyMessage
+        {
+            return AddSubscriptionInternal<TMessage>(deliveryAction, messageFilter, useStrongReferences, DefaultTinyMessageProxy.Instance);
+        }
+
+        /// <summary>
+        /// Subscribe to a message type with the given destination and delivery action with the given filter.
+        /// Messages will be delivered via the specified proxy.
+        /// All references are held with WeakReferences
+        /// 
+        /// Only messages that "pass" the filter will be delivered.
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="deliveryAction">Action to invoke when message is delivered</param>
+        /// <param name="useStrongReferences">Use strong references to destination and deliveryAction </param>
+        /// <param name="proxy">Proxy to use when delivering the messages</param>
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        public TinyMessageSubscriptionToken Subscribe<TMessage>(Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter, bool useStrongReferences, ITinyMessageProxy proxy) where TMessage : class, ITinyMessage
+        {
+            return AddSubscriptionInternal<TMessage>(deliveryAction, messageFilter, useStrongReferences, proxy);
+        }
+
+        /// <summary>
+        /// Unsubscribe from a particular message type.
+        /// 
+        /// Does not throw an exception if the subscription is not found.
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="subscriptionToken">Subscription token received from Subscribe</param>
+        public void Unsubscribe<TMessage>(TinyMessageSubscriptionToken subscriptionToken) where TMessage : class, ITinyMessage
+        {
+            RemoveSubscriptionInternal<TMessage>(subscriptionToken);
+        }
+
+        /// <summary>
+        /// Publish a message to any subscribers
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="message">Message to deliver</param>
+        public void Publish<TMessage>(TMessage message) where TMessage : class, ITinyMessage
+        {
+            PublishInternal<TMessage>(message);
+        }
+
+        /// <summary>
+        /// Publish a message to any subscribers asynchronously
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="message">Message to deliver</param>
+        public void PublishAsync<TMessage>(TMessage message) where TMessage : class, ITinyMessage
+        {
+            PublishAsyncInternal<TMessage>(message, null);
+        }
+
+        /// <summary>
+        /// Publish a message to any subscribers asynchronously
+        /// </summary>
+        /// <typeparam name="TMessage">Type of message</typeparam>
+        /// <param name="message">Message to deliver</param>
+        /// <param name="callback">AsyncCallback called on completion</param>
+        public void PublishAsync<TMessage>(TMessage message, AsyncCallback callback) where TMessage : class, ITinyMessage
+        {
+            PublishAsyncInternal<TMessage>(message, callback);
+        }
+        #endregion
+
+        #region Internal Methods
+        private TinyMessageSubscriptionToken AddSubscriptionInternal<TMessage>(Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter, bool strongReference, ITinyMessageProxy proxy)
+                where TMessage : class, ITinyMessage
+        {
+            if (deliveryAction == null)
+                throw new ArgumentNullException("deliveryAction");
+
+            if (messageFilter == null)
+                throw new ArgumentNullException("messageFilter");
+
+            if (proxy == null)
+                throw new ArgumentNullException("proxy");
+
+            lock (_SubscriptionsPadlock)
+            {
+                List<SubscriptionItem> currentSubscriptions;
+
+                if (!_Subscriptions.TryGetValue(typeof(TMessage), out currentSubscriptions))
+                {
+                    currentSubscriptions = new List<SubscriptionItem>();
+                    _Subscriptions[typeof(TMessage)] = currentSubscriptions;
+                }
+
+                var subscriptionToken = new TinyMessageSubscriptionToken();
+
+                ITinyMessageSubscription subscription;
+                if (strongReference)
+                    subscription = new StrongTinyMessageSubscription<TMessage>(subscriptionToken, deliveryAction, messageFilter);
+                else
+                    subscription = new WeakTinyMessageSubscription<TMessage>(subscriptionToken, deliveryAction, messageFilter);
+
+                currentSubscriptions.Add(new SubscriptionItem(proxy, subscription));
+
+                return subscriptionToken;
+            }
+        }
+
+        private void RemoveSubscriptionInternal<TMessage>(TinyMessageSubscriptionToken subscriptionToken)
+                where TMessage : class, ITinyMessage
+        {
+            if (subscriptionToken == null)
+                throw new ArgumentNullException("subscriptionToken");
+
+            lock (_SubscriptionsPadlock)
+            {
+                List<SubscriptionItem> currentSubscriptions;
+                if (!_Subscriptions.TryGetValue(typeof(TMessage), out currentSubscriptions))
+                    return;
+
+                var currentlySubscribed = (from sub in currentSubscriptions
+                                           where object.ReferenceEquals(sub.Subscription.SubscriptionToken, subscriptionToken)
+                                           select sub).ToList();
+
+                currentlySubscribed.ForEach(sub => currentSubscriptions.Remove(sub));
+            }
+        }
+
+        private void PublishInternal<TMessage>(TMessage message)
+                where TMessage : class, ITinyMessage
+        {
+            if (message == null)
+                throw new ArgumentNullException("message");
+
+            List<SubscriptionItem> currentlySubscribed;
+            lock (_SubscriptionsPadlock)
+            {
+                List<SubscriptionItem> currentSubscriptions;
+                if (!_Subscriptions.TryGetValue(typeof(TMessage), out currentSubscriptions))
+                    return;
+
+                currentlySubscribed = (from sub in currentSubscriptions
+                                       where sub.Subscription.ShouldAttemptDelivery(message)
+                                       select sub).ToList();
+            }
+
+            currentlySubscribed.ForEach(sub =>
+            {
+                try
+                {
+                    sub.Proxy.Deliver(message, sub.Subscription);
+                }
+                catch (Exception)
+                {
+                    // Ignore any errors and carry on
+                    // TODO - add to a list of erroring subs and remove them?
+                }
+            });
+        }
+
+        private void PublishAsyncInternal<TMessage>(TMessage message, AsyncCallback callback) where TMessage : class, ITinyMessage
+        {
+            Action publishAction = () => { PublishInternal<TMessage>(message); };
+
+            publishAction.BeginInvoke(callback, null);
+        }
+        #endregion
+    }
+    #endregion
+}