public void Unsubscribe(Address client, IEnumerable <MessageType> messageTypes)
        {
            Logger.Debug("Unsubscribe called");

            if (client == null)
            {
                Logger.Debug("Client is null!  Throwing");
                throw new ArgumentNullException("client");
            }

            if (messageTypes == null)
            {
                Logger.Debug("MessageTypes is null!  Throwing");
                throw new ArgumentNullException("messageTypes");
            }

            using (ISubscriptionDbContext dbc = _dbContextFactory.CreateSubscriptionDbContext())
                using (DbContextTransaction transaction = dbc.Database.BeginTransaction(IsolationLevel.ReadCommitted))
                {
                    try
                    {
                        string        clientAddress      = client.ToString();
                        List <string> messageTypeStrings = messageTypes.Select(mt => mt.ToString()).ToList();

                        Logger.DebugFormat("Finding existing subscriptions for message types requested of {0}", clientAddress);
                        List <SubscriptionEntity> existing = dbc.Subscriptions.Where(
                            s => s.SubscriberEndpoint == clientAddress &&
                            messageTypeStrings.Contains(s.MessageType))
                                                             .ToList();

                        Logger.DebugFormat("{0} subscription(s) found, removing them.", existing.Count);
                        dbc.Subscriptions.RemoveRange(existing);

                        Logger.Debug("Saving changes and committing transaction.");
                        dbc.SaveChanges();
                        transaction.Commit();
                    }
                    catch (Exception ex)
                    {
                        Logger.Error("Some error happened while removing subscriptions", ex);
                        transaction.Rollback();
                        throw;
                    }
                }
        }
        public void Subscribe(Address client, IEnumerable <MessageType> messageTypes)
        {
            Logger.Debug("Subscribe called");

            if (client == null)
            {
                Logger.Debug("Client is null!  Throwing");
                throw new ArgumentNullException("client");
            }

            if (messageTypes == null)
            {
                Logger.Debug("Message types is null!  Throwing");
                throw new ArgumentNullException("messageTypes");
            }

            string                    clientAddress      = client.ToString();
            List <string>             messageTypeStrings = new List <string>();
            List <SubscriptionEntity> subscriptions      = new List <SubscriptionEntity>();

            foreach (MessageType mt in messageTypes.Distinct())
            {
                string messageTypeString = mt.ToString();

                Logger.DebugFormat("Adding message type {0} to {1}.", messageTypeString, clientAddress);

                messageTypeStrings.Add(messageTypeString);
                subscriptions.Add(
                    new SubscriptionEntity
                {
                    SubscriberEndpoint = clientAddress,
                    MessageType        = messageTypeString
                });
            }

            using (ISubscriptionDbContext dbc = _dbContextFactory.CreateSubscriptionDbContext())
                using (DbContextTransaction transaction = dbc.Database.BeginTransaction(IsolationLevel.ReadCommitted))
                {
                    try
                    {
                        Logger.DebugFormat("Gathering subscriptions for {0} and any of the requested message types.", clientAddress);
                        var existing = dbc.Subscriptions.Where(
                            s => s.SubscriberEndpoint == clientAddress &&
                            messageTypeStrings.Contains(s.MessageType));

                        foreach (var subscription in subscriptions)
                        {
                            if (existing.Any(s => s.MessageType == subscription.MessageType))
                            {
                                Logger.DebugFormat("{0} already is subscribed to {1}", clientAddress, subscription.MessageType);
                                continue;
                            }

                            Logger.DebugFormat(
                                "{0} doesn't yet have {1}.  Subscribing...",
                                clientAddress,
                                subscription.MessageType);
                            dbc.Subscriptions.Add(subscription);
                        }

                        Logger.Debug("Saving changes and committing transaction.");
                        dbc.SaveChanges();
                        transaction.Commit();
                    }
                    catch (Exception ex)
                    {
                        Logger.Error("Some error happened while saving subscriptions", ex);
                        transaction.Rollback();
                        throw;
                    }
                }
        }