# HG changeset patch
# User Steven Robbins
# Date 1268479283 0
# Branch messenger
# Node ID d1a71995aa8149e71a4345b4b2105c17279ee2b9
# Parent  fc8f518302951c5e8fa1eca21c2c58a8e591eee9
Removed requirement for destination - replaced with returned "token".
Action is enough to keep reference alive (if neccessary)

diff -r fc8f518302951c5e8fa1eca21c2c58a8e591eee9 -r d1a71995aa8149e71a4345b4b2105c17279ee2b9 TinyIoC.Tests/TinyMessengerTests.cs
--- a/TinyIoC.Tests/TinyMessengerTests.cs	Fri Mar 12 20:57:07 2010 +0000
+++ b/TinyIoC.Tests/TinyMessengerTests.cs	Sat Mar 13 11:21:23 2010 +0000
@@ -8,6 +8,7 @@
 
 namespace TinyIoC.Tests
 {
+
     [TestClass]
     public class TinyMessengerTests
     {
@@ -18,36 +19,37 @@
         }
 
         [TestMethod]
-        public void Subscribe_ValidDestinationAndDeliverAction_DoesNotThrow()
+        public void Subscribe_ValidDeliverAction_DoesNotThrow()
         {
             var messenger = UtilityMethods.GetMessenger();
 
-            messenger.Subscribe<TestMessage>(this, new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>));
+            messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>));
         }
 
         [TestMethod]
-        public void Subscribe_ValidDestinationAndDeliverActionWIthStrongReferences_DoesNotThrow()
+        public void SubScribe_ValidDeliveryAction_ReturnsRegistrationObject()
         {
             var messenger = UtilityMethods.GetMessenger();
 
-            messenger.Subscribe<TestMessage>(this, new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), true);
+            var output = messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>));
+
+            Assert.IsInstanceOfType(output, typeof(TinyMessageSubscription));
         }
 
         [TestMethod]
-        public void Subscribe_ValidDestinationDeliveryActionAndFilter_DoesNotThrow()
+        public void Subscribe_ValidDeliverActionWIthStrongReferences_DoesNotThrow()
         {
             var messenger = UtilityMethods.GetMessenger();
 
-            messenger.Subscribe<TestMessage>(this, new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>));
+            messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), true);
         }
 
         [TestMethod]
-        [ExpectedException(typeof(ArgumentNullException))]
-        public void Subscribe_NullDestination_Throws()
+        public void Subscribe_ValidDeliveryActionAndFilter_DoesNotThrow()
         {
             var messenger = UtilityMethods.GetMessenger();
 
-            messenger.Subscribe<TestMessage>(null, new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>));
+            messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>));
         }
 
         [TestMethod]
@@ -56,7 +58,7 @@
         {
             var messenger = UtilityMethods.GetMessenger();
 
-            messenger.Subscribe<TestMessage>(this, null, new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>));
+            messenger.Subscribe<TestMessage>(null, new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>));
         }
 
         [TestMethod]
@@ -65,39 +67,12 @@
         {
             var messenger = UtilityMethods.GetMessenger();
 
-            messenger.Subscribe<TestMessage>(this, new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), null);
-        }
-
-        [TestMethod]
-        [ExpectedException(typeof(TinyMessengerSubscriptionException))]
-        public void Subscribe_SameDestinationAndEventTwice_ThrowsException()
-        {
-            var messenger = UtilityMethods.GetMessenger();
-
-            messenger.Subscribe<TestMessage>(this, new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>));
-            messenger.Subscribe<TestMessage>(this, new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>));
-        }
-
-        [TestMethod]
-        public void Unsubscribe_NoPreviousSubscription_DoesNotThrow()
-        {
-            var messenger = UtilityMethods.GetMessenger();
-
-            messenger.Unsubscribe<TestMessage>(this);
-        }
-
-        [TestMethod]
-        public void Unsubscribe_PreviousSubscription_DoesNotThrow()
-        {
-            var messenger = UtilityMethods.GetMessenger();
-            messenger.Subscribe<TestMessage>(this, new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>));
-
-            messenger.Unsubscribe<TestMessage>(this);
+            messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), null);
         }
 
         [TestMethod]
         [ExpectedException(typeof(ArgumentNullException))]
-        public void Unsubscribe_NullDestination_Throws()
+        public void Unsubscribe_NullSubscriptionObject_Throws()
         {
             var messenger = UtilityMethods.GetMessenger();
 
@@ -105,13 +80,22 @@
         }
 
         [TestMethod]
-        public void Unsubscribe_PreviousSubscription_CanSubscribeAgainWithoutThrowing()
+        public void Unsubscribe_PreviousSubscription_DoesNotThrow()
         {
             var messenger = UtilityMethods.GetMessenger();
-            messenger.Subscribe<TestMessage>(this, new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>));
-            messenger.Unsubscribe<TestMessage>(this);
+            var subscription = messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>));
 
-            messenger.Subscribe<TestMessage>(this, 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]
@@ -135,7 +119,7 @@
         public void Publish_Subscriber_DoesNotThrow()
         {
             var messenger = UtilityMethods.GetMessenger();
-            messenger.Subscribe<TestMessage>(this, new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>));
+            messenger.Subscribe<TestMessage>(new Action<TestMessage>(UtilityMethods.FakeDeliveryAction<TestMessage>), new Func<TestMessage, bool>(UtilityMethods.FakeMessageFilter<TestMessage>));
 
             messenger.Publish<TestMessage>(new TestMessage(this));
         }
@@ -145,7 +129,7 @@
         {
             var messenger = UtilityMethods.GetMessenger();
             bool received = false;
-            messenger.Subscribe<TestMessage>(this, (m) => { received = true; });
+            messenger.Subscribe<TestMessage>((m) => { received = true; });
 
             messenger.Publish<TestMessage>(new TestMessage(this));
 
@@ -153,11 +137,24 @@
         }
 
         [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>(this, (m) => { received = true; }, (m) => false);
+            messenger.Subscribe<TestMessage>((m) => { received = true; }, (m) => false);
 
             messenger.Publish<TestMessage>(new TestMessage(this));
 
@@ -170,7 +167,7 @@
             var messenger = UtilityMethods.GetMessenger();
             ITinyMessage receivedMessage = null;
             var payload = new TestMessage(this);
-            messenger.Subscribe<TestMessage>(this, (m) => { receivedMessage = m; });
+            messenger.Subscribe<TestMessage>((m) => { receivedMessage = m; });
 
             messenger.Publish<TestMessage>(payload);
 
@@ -182,7 +179,7 @@
         {
             var messenger = UtilityMethods.GetMessenger();
             var output = string.Empty;
-            messenger.Subscribe<GenericTinyMessage<string>>(this, (m) => { output = m._Content; });
+            messenger.Subscribe<GenericTinyMessage<string>>((m) => { output = m._Content; });
         }
 
         [TestMethod]
@@ -197,7 +194,7 @@
         {
             var messenger = UtilityMethods.GetMessenger();
             var output = string.Empty;
-            messenger.Subscribe<GenericTinyMessage<string>>(this, (m) => { output = m._Content; });
+            messenger.Subscribe<GenericTinyMessage<string>>((m) => { output = m._Content; });
             messenger.Publish(new GenericTinyMessage<string>(this, "Testing"));
 
             Assert.AreEqual("Testing", output);
diff -r fc8f518302951c5e8fa1eca21c2c58a8e591eee9 -r d1a71995aa8149e71a4345b4b2105c17279ee2b9 TinyIoC/TinyMessenger.cs
--- a/TinyIoC/TinyMessenger.cs	Fri Mar 12 20:57:07 2010 +0000
+++ b/TinyIoC/TinyMessenger.cs	Sat Mar 13 11:21:23 2010 +0000
@@ -84,6 +84,13 @@
             _Content = content;
         }
     }
+
+    /// <summary>
+    /// Represents an active subscription to a message
+    /// </summary>
+    public sealed class TinyMessageSubscription
+    {
+    }
     #endregion
 
     #region Exceptions
@@ -121,10 +128,9 @@
         /// All messages of this type will be delivered.
         /// </summary>
         /// <typeparam name="TMessage">Type of message</typeparam>
-        /// <param name="destination">Destination (usually "this") - used for Unsubscribe <see cref="Unsubscribe"/></param>
         /// <param name="deliveryAction">Action to invoke when message is delivered</param>
-        /// <exception cref="TinyMessengerSubscriptionException">Thrown when attempting to subscribe more than once with the same destination and message type</exception> 
-        void Subscribe<TMessage>(object destination, Action<TMessage> deliveryAction) where TMessage : class, ITinyMessage;
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        TinyMessageSubscription Subscribe<TMessage>(Action<TMessage> deliveryAction) where TMessage : class, ITinyMessage;
 
         /// <summary>
         /// Subscribe to a message type with the given destination and delivery action.
@@ -132,11 +138,10 @@
         /// All messages of this type will be delivered.
         /// </summary>
         /// <typeparam name="TMessage">Type of message</typeparam>
-        /// <param name="destination">Destination (usually "this") - used for Unsubscribe <see cref="Unsubscribe"/></param>
         /// <param name="deliveryAction">Action to invoke when message is delivered</param>
         /// <param name="useStrongReferences">Use strong references to destination and deliveryAction </param>
-        /// <exception cref="TinyMessengerSubscriptionException">Thrown when attempting to subscribe more than once with the same destination and message type</exception> 
-        void Subscribe<TMessage>(object destination, Action<TMessage> deliveryAction, bool useStrongReferences) where TMessage : class, ITinyMessage;
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        TinyMessageSubscription Subscribe<TMessage>(Action<TMessage> deliveryAction, bool useStrongReferences) where TMessage : class, ITinyMessage;
 
         /// <summary>
         /// Subscribe to a message type with the given destination and delivery action with the given filter.
@@ -145,10 +150,9 @@
         /// Only messages that "pass" the filter will be delivered.
         /// </summary>
         /// <typeparam name="TMessage">Type of message</typeparam>
-        /// <param name="destination">Destination (usually "this") - used for Unsubscribe <see cref="Unsubscribe"/></param>
         /// <param name="deliveryAction">Action to invoke when message is delivered</param>
-        /// <exception cref="TinyMessengerSubscriptionException">Thrown when attempting to subscribe more than once with the same destination and message type</exception>          
-        void Subscribe<TMessage>(object destination, Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter) where TMessage : class, ITinyMessage;
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        TinyMessageSubscription 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.
@@ -157,11 +161,10 @@
         /// Only messages that "pass" the filter will be delivered.
         /// </summary>
         /// <typeparam name="TMessage">Type of message</typeparam>
-        /// <param name="destination">Destination (usually "this") - held in a weak reference used for Unsubscribe <see cref="Unsubscribe"/></param>
         /// <param name="deliveryAction">Action to invoke when message is delivered</param>
         /// <param name="useStrongReferences">Use strong references to destination and deliveryAction </param>
-        /// <exception cref="TinyMessengerSubscriptionException">Thrown when attempting to subscribe more than once with the same destination and message type</exception>          
-        void Subscribe<TMessage>(object destination, Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter, bool useStrongReferences) where TMessage : class, ITinyMessage;
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        TinyMessageSubscription Subscribe<TMessage>(Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter, bool useStrongReferences) where TMessage : class, ITinyMessage;
 
         /// <summary>
         /// Unsubscribe from a particular message type.
@@ -170,7 +173,7 @@
         /// </summary>
         /// <typeparam name="TMessage">Type of message</typeparam>
         /// <param name="destination">Destination (usually "this") that was used to subscribe initially</param>
-        void Unsubscribe<TMessage>(object destination) where TMessage : class, ITinyMessage;
+        void Unsubscribe<TMessage>(TinyMessageSubscription subscription) where TMessage : class, ITinyMessage;
 
         /// <summary>
         /// Publish a message to any subscribers
@@ -192,38 +195,35 @@
         // can't think of any other way without generic contravariance?
         private interface ITinyMessageSubscription
         {
-            object Destination { get; }
-            bool CanDeliver(ITinyMessage message);
+            TinyMessageSubscription Subscription { get; }
+            bool ShouldAttemptDelivery(ITinyMessage message);
             void Deliver(ITinyMessage message);
         }
 
         private class WeakTinyMessageSubscription<TMessage> : ITinyMessageSubscription
             where TMessage : class, ITinyMessage
         {
-            protected WeakReference _Destination;
+            protected TinyMessageSubscription _Subscription;
             protected WeakReference _DeliveryAction;
             protected WeakReference _MessageFilter;
 
-            public object Destination
+            public TinyMessageSubscription Subscription
             {
-                get { return _Destination.Target; }
+                get { return _Subscription; }
             }
 
-            public bool CanDeliver(ITinyMessage message)
+            public bool ShouldAttemptDelivery(ITinyMessage message)
             {
                 if (!(message is TMessage))
                     return false;
 
-                if (!_Destination.IsAlive)
-                    return false;
-
                 if (!_DeliveryAction.IsAlive)
                     return false;
 
                 if (!_MessageFilter.IsAlive)
                     return false;
 
-                return ((Func<TMessage, bool>) _MessageFilter.Target).Invoke(message as TMessage);
+                return ((Func<TMessage, bool>)_MessageFilter.Target).Invoke(message as TMessage);
             }
 
             public void Deliver(ITinyMessage message)
@@ -231,15 +231,12 @@
                 if (!(message is TMessage))
                     throw new ArgumentException("Message is not the correct type");
 
-                if (!_Destination.IsAlive)
-                    return;
-
                 if (!_DeliveryAction.IsAlive)
                     return;
 
                 try
                 {
-                    ((Action<TMessage>) _DeliveryAction.Target).Invoke(message as TMessage);
+                    ((Action<TMessage>)_DeliveryAction.Target).Invoke(message as TMessage);
                 }
                 catch (Exception)
                 {
@@ -253,10 +250,10 @@
             /// <param name="destination">Destination object</param>
             /// <param name="deliveryAction">Delivery action</param>
             /// <param name="messageFilter">Filter function</param>
-            public WeakTinyMessageSubscription(object destination, Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter)
+            public WeakTinyMessageSubscription(TinyMessageSubscription subscription, Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter)
             {
-                if (destination == null)
-                    throw new ArgumentNullException("destination");
+                if (subscription == null)
+                    throw new ArgumentNullException("subscription");
 
                 if (deliveryAction == null)
                     throw new ArgumentNullException("deliveryAction");
@@ -264,7 +261,7 @@
                 if (messageFilter == null)
                     throw new ArgumentNullException("messageFilter");
 
-                _Destination = new WeakReference(destination);
+                _Subscription = subscription;
                 _DeliveryAction = new WeakReference(deliveryAction);
                 _MessageFilter = new WeakReference(messageFilter);
             }
@@ -273,16 +270,16 @@
         private class StrongTinyMessageSubscription<TMessage> : ITinyMessageSubscription
             where TMessage : class, ITinyMessage
         {
-            protected object _Destination;
+            protected TinyMessageSubscription _Subscription;
             protected Action<TMessage> _DeliveryAction;
             protected Func<TMessage, bool> _MessageFilter;
 
-            public object Destination
+            public TinyMessageSubscription Subscription
             {
-                get { return _Destination; }
+                get { return _Subscription; }
             }
 
-            public bool CanDeliver(ITinyMessage message)
+            public bool ShouldAttemptDelivery(ITinyMessage message)
             {
                 if (!(message is TMessage))
                     return false;
@@ -311,10 +308,10 @@
             /// <param name="destination">Destination object</param>
             /// <param name="deliveryAction">Delivery action</param>
             /// <param name="messageFilter">Filter function</param>
-            public StrongTinyMessageSubscription(object destination, Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter)
+            public StrongTinyMessageSubscription(TinyMessageSubscription subscription, Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter)
             {
-                if (destination == null)
-                    throw new ArgumentNullException("destination");
+                if (subscription == null)
+                    throw new ArgumentNullException("subscription");
 
                 if (deliveryAction == null)
                     throw new ArgumentNullException("deliveryAction");
@@ -322,7 +319,7 @@
                 if (messageFilter == null)
                     throw new ArgumentNullException("messageFilter");
 
-                _Destination = destination;
+                _Subscription = subscription;
                 _DeliveryAction = deliveryAction;
                 _MessageFilter = messageFilter;
             }
@@ -342,12 +339,11 @@
         /// All messages of this type will be delivered.
         /// </summary>
         /// <typeparam name="TMessage">Type of message</typeparam>
-        /// <param name="destination">Destination (usually "this") - used for Unsubscribe <see cref="Unsubscribe"/></param>
         /// <param name="deliveryAction">Action to invoke when message is delivered</param>
-        /// <exception cref="TinyMessengerSubscriptionException">Thrown when attempting to subscribe more than once with the same destination and message type</exception> 
-        public void Subscribe<TMessage>(object destination, Action<TMessage> deliveryAction) where TMessage : class, ITinyMessage
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        public TinyMessageSubscription Subscribe<TMessage>(Action<TMessage> deliveryAction) where TMessage : class, ITinyMessage
         {
-            AddSubscriptionInternal<TMessage>(destination, deliveryAction, (m) => true, false);
+            return AddSubscriptionInternal<TMessage>(deliveryAction, (m) => true, false);
         }
 
         /// <summary>
@@ -356,13 +352,12 @@
         /// All messages of this type will be delivered.
         /// </summary>
         /// <typeparam name="TMessage">Type of message</typeparam>
-        /// <param name="destination">Destination (usually "this") - used for Unsubscribe <see cref="Unsubscribe"/></param>
         /// <param name="deliveryAction">Action to invoke when message is delivered</param>
         /// <param name="useStrongReferences">Use strong references to destination and deliveryAction </param>
-        /// <exception cref="TinyMessengerSubscriptionException">Thrown when attempting to subscribe more than once with the same destination and message type</exception> 
-        public void Subscribe<TMessage>(object destination, Action<TMessage> deliveryAction, bool useStrongReferences) where TMessage : class, ITinyMessage
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        public TinyMessageSubscription Subscribe<TMessage>(Action<TMessage> deliveryAction, bool useStrongReferences) where TMessage : class, ITinyMessage
         {
-            AddSubscriptionInternal<TMessage>(destination, deliveryAction, (m) => true, useStrongReferences);
+            return AddSubscriptionInternal<TMessage>(deliveryAction, (m) => true, useStrongReferences);
         }
 
         /// <summary>
@@ -372,12 +367,11 @@
         /// Only messages that "pass" the filter will be delivered.
         /// </summary>
         /// <typeparam name="TMessage">Type of message</typeparam>
-        /// <param name="destination">Destination (usually "this") - used for Unsubscribe <see cref="Unsubscribe"/></param>
         /// <param name="deliveryAction">Action to invoke when message is delivered</param>
-        /// <exception cref="TinyMessengerSubscriptionException">Thrown when attempting to subscribe more than once with the same destination and message type</exception>          
-        public void Subscribe<TMessage>(object destination, Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter) where TMessage : class, ITinyMessage
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        public TinyMessageSubscription Subscribe<TMessage>(Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter) where TMessage : class, ITinyMessage
         {
-            AddSubscriptionInternal<TMessage>(destination, deliveryAction, messageFilter, false);
+            return AddSubscriptionInternal<TMessage>(deliveryAction, messageFilter, false);
         }
 
         /// <summary>
@@ -387,13 +381,12 @@
         /// Only messages that "pass" the filter will be delivered.
         /// </summary>
         /// <typeparam name="TMessage">Type of message</typeparam>
-        /// <param name="destination">Destination (usually "this") - held in a weak reference used for Unsubscribe <see cref="Unsubscribe"/></param>
         /// <param name="deliveryAction">Action to invoke when message is delivered</param>
         /// <param name="useStrongReferences">Use strong references to destination and deliveryAction </param>
-        /// <exception cref="TinyMessengerSubscriptionException">Thrown when attempting to subscribe more than once with the same destination and message type</exception>          
-        public void Subscribe<TMessage>(object destination, Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter, bool useStrongReferences) where TMessage : class, ITinyMessage
+        /// <returns>TinyMessageSubscription used to unsubscribing</returns>
+        public TinyMessageSubscription Subscribe<TMessage>(Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter, bool useStrongReferences) where TMessage : class, ITinyMessage
         {
-            AddSubscriptionInternal<TMessage>(destination, deliveryAction, messageFilter, useStrongReferences);
+            return AddSubscriptionInternal<TMessage>(deliveryAction, messageFilter, useStrongReferences);
         }
 
         /// <summary>
@@ -403,9 +396,9 @@
         /// </summary>
         /// <typeparam name="TMessage">Type of message</typeparam>
         /// <param name="destination">Destination (usually "this") that was used to subscribe initially</param>
-        public void Unsubscribe<TMessage>(object destination) where TMessage : class, ITinyMessage
+        public void Unsubscribe<TMessage>(TinyMessageSubscription subscription) where TMessage : class, ITinyMessage
         {
-            RemoveSubscriptionInternal<TMessage>(destination);
+            RemoveSubscriptionInternal<TMessage>(subscription);
         }
 
         /// <summary>
@@ -420,12 +413,9 @@
         #endregion
 
         #region Internal Methods
-        private void AddSubscriptionInternal<TMessage>(object destination, Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter, bool strongReference)
+        private TinyMessageSubscription AddSubscriptionInternal<TMessage>(Action<TMessage> deliveryAction, Func<TMessage, bool> messageFilter, bool strongReference)
                 where TMessage : class, ITinyMessage
         {
-            if (destination == null)
-                throw new ArgumentNullException("destination");
-
             if (deliveryAction == null)
                 throw new ArgumentNullException("deliveryAction");
 
@@ -442,25 +432,22 @@
                     _Subscriptions[typeof(TMessage)] = currentSubscriptions;
                 }
 
-                var currentlySubscribed = from sub in currentSubscriptions
-                                          where (sub.Destination != null) && (object.ReferenceEquals(sub.Destination, destination))
-                                          select sub;
-
-                if (currentlySubscribed.Count() != 0)
-                    throw new TinyMessengerSubscriptionException(typeof(TMessage), "An existing subscription for that message type and destination already exists");
+                var subscription = new TinyMessageSubscription();
 
                 if (strongReference)
-                    currentSubscriptions.Add(new StrongTinyMessageSubscription<TMessage>(destination, deliveryAction, messageFilter));
+                    currentSubscriptions.Add(new StrongTinyMessageSubscription<TMessage>(subscription, deliveryAction, messageFilter));
                 else
-                    currentSubscriptions.Add(new WeakTinyMessageSubscription<TMessage>(destination, deliveryAction, messageFilter));
+                    currentSubscriptions.Add(new WeakTinyMessageSubscription<TMessage>(subscription, deliveryAction, messageFilter));
+
+                return subscription;
             }
         }
 
-        private void RemoveSubscriptionInternal<TMessage>(object destination)
+        private void RemoveSubscriptionInternal<TMessage>(TinyMessageSubscription subscription)
                 where TMessage : class, ITinyMessage
         {
-            if (destination == null)
-                throw new ArgumentNullException("destination");
+            if (subscription == null)
+                throw new ArgumentNullException("subscription");
 
             lock (_SubscriptionsPadlock)
             {
@@ -469,7 +456,7 @@
                     return;
 
                 var currentlySubscribed = (from sub in currentSubscriptions
-                                           where (sub.Destination != null) && (object.ReferenceEquals(sub.Destination, destination))
+                                           where object.ReferenceEquals(sub.Subscription, subscription)
                                            select sub).ToList();
 
                 currentlySubscribed.ForEach(sub => currentSubscriptions.Remove(sub));
@@ -490,7 +477,7 @@
                     return;
 
                 currentlySubscribed = (from sub in currentSubscriptions
-                                       where (sub.Destination != null) && (sub.CanDeliver(message))
+                                       where sub.ShouldAttemptDelivery(message)
                                        select sub).ToList();
             }