Question

I’m implementing a simple chat in .NET using Rx on the basis of this example:
https://blogs.claritycon.com/blog/2011/04/roll-your-own-mvc-3-long-polling-chat-site/

There’s a method that, using LongPolling waits for new messages to come:

public static void CheckForMessagesAsync(Action<List<MessageInfo>> onMessages)
{
    var queued = ThreadPool.QueueUserWorkItem(new WaitCallback(parm =>
    {
        var msgs = new List<MessageInfo>();
        var wait = new AutoResetEvent(false);
        using (var subscriber = _messages.Subscribe(msg =>
                                        {
                                            msgs.Add(msg);
                                            wait.Set();
                                        }))
        {
            // Wait for the max seconds for a new msg
            wait.WaitOne(TimeSpan.FromSeconds(MaxWaitSeconds));
        }

        ((Action<List<MessageInfo>>)parm)(msgs);
    }), onMessages);

    if (!queued)
        onMessages(new List<MessageInfo>());
}

Using this method I lose messages appearing between disconnecting and disposing the observer and re-connecting.
How to correctly implement this mechanism to not lose those messages?

Answer 1

I found a solution. I do not know whether it is the most beautiful in the world, but it works.
I created private property, so each user can have multiple sessions:

private ConcurrentDictionary<long, ChatServerUserSessions> _chatServerUserSessionInfoDictionary = new ConcurrentDictionary<long, ChatServerUserSessions>();

and session class:

public class ChatServerUserSessions
{
    public long UserId { get; set; }

    public string UserName { get; set; }

    public ConcurrentDictionary<string, ChatServerUserSessionInfo> Sessions { get; set; }

    public object Lock { get; set; }
}

and for each session I created class:

public class ChatServerUserSessionInfo : IObservable<ChatServerRoomActivityInfoBase>, IDisposable
{
    public string SessionId { get; set; }

    public List<long> SubscribedRoomIds { get; set; }

    public DateTime SubscriptionTicketInvalidationDate { get; set; }

    public Queue<ChatServerRoomActivityInfoBase> MessagesQueue { get; set; }

    private IDisposable subscription;
    private List<IObserver<ChatServerRoomActivityInfoBase>> observers;
    private ChatServerUserSessions parentUserSessions;

    public ChatServerUserSessionInfo(string sessionId, DateTime subscriptionTicketInvalidationDate, Subject<ChatServerRoomActivityInfoBase> chatServerRoomActivity, ChatServerUserSessions parentUserSessions)
    {
        this.SessionId = sessionId;
        this.SubscribedRoomIds = new List<long>();
        this.SubscriptionTicketInvalidationDate = subscriptionTicketInvalidationDate;
        this.MessagesQueue = new Queue<ChatServerRoomActivityInfoBase>();
        this.parentUserSessions = parentUserSessions;

        subscription = chatServerRoomActivity.Subscribe(activity =>
        {
            lock (parentUserSessions.Lock)
            {
                if (this.SubscribedRoomIds.Contains(activity.RoomId))
                {
                    this.MessagesQueue.Enqueue(activity);

                    foreach (var observer in observers)
                    {
                        observer.OnNext(activity);
                    }
                }
            }
        });

        observers = new List<IObserver<ChatServerRoomActivityInfoBase>>();
    }

    ~ChatServerUserSessionInfo()
    {
        Dispose();
    }

    public void Dispose()
    {
        if (subscription != null)
        {
            subscription.Dispose();
            subscription = null;
        }

        this.observers = null;

        GC.SuppressFinalize(this);
    }

    public IDisposable Subscribe(IObserver<ChatServerRoomActivityInfoBase> observer)
    {
        lock (parentUserSessions.Lock)
        {
            this.observers.Add(observer);
            return (IDisposable)new Subscription(this, observer);
        }
    }

    private void Unsubscribe(IObserver<ChatServerRoomActivityInfoBase> observer)
    {
        lock (parentUserSessions.Lock)
        {
            if (this.observers == null)
            {
                return;
            }

            this.observers.Remove(observer);
        }
    }

    private class Subscription : IDisposable
    {
        private ChatServerUserSessionInfo subject;
        private IObserver<ChatServerRoomActivityInfoBase> observer;

        public Subscription(ChatServerUserSessionInfo subject, IObserver<ChatServerRoomActivityInfoBase> observer)
        {
            this.subject = subject;
            this.observer = observer;
        }

        public void Dispose()
        {
            IObserver<ChatServerRoomActivityInfoBase> observer = Interlocked.Exchange<IObserver<ChatServerRoomActivityInfoBase>>(ref this.observer, (IObserver<ChatServerRoomActivityInfoBase>)null);
            if (observer == null)
            {
                return;
            }

            this.subject.Unsubscribe(observer);
            this.subject = (ChatServerUserSessionInfo)null;
        }
    }
}

Each user session has own MessageQueue and is subscribed to global chat room activity subject. ChatRoomActivityMessages are persisted for each session individualy. Here is method for retrieving messages:

public void CheckForChatRoomsActivityAsync(long userId, string userName, Action<List<ChatServerRoomActivityInfoBase>> onChatRoomActivity)
    {
        var sessionId = GetCurrentSessionId();
        var chatServerUserSessions = GetChatServerUserSessions(userId, userName);

        lock (chatServerUserSessions.Lock)
        {
            var userSession = GetChatServerUserSessionInfo(sessionId, chatServerUserSessions);
            ProlongSubscriptions(userSession);

            if (userSession.MessagesQueue.Count > 0)
            {
                var activities = new List<ChatServerRoomActivityInfoBase>();
                while (userSession.MessagesQueue.Count > 0)
                {
                    activities.Add(userSession.MessagesQueue.Dequeue());
                }

                onChatRoomActivity(activities);
            }
            else
            {
                var queued = ThreadPool.QueueUserWorkItem(new WaitCallback(parm =>
                {
                    var activities = new List<ChatServerRoomActivityInfoBase>();
                    var wait = new AutoResetEvent(false);

                    using (var subscriber = userSession.Subscribe(activity =>
                    {
                        lock (chatServerUserSessions.Lock)
                        {
                            activities.Add(activity);
                            userSession.MessagesQueue.Dequeue();

                            wait.Set();
                        }
                    }))
                    {
                        wait.WaitOne(TimeSpan.FromSeconds(CheckForActivityMaxWaitSeconds));
                    }

                    ((Action<List<ChatServerRoomActivityInfoBase>>)parm)(activities);
                }), onChatRoomActivity);

                if (!queued)
                {
                    onChatRoomActivity(new List<ChatServerRoomActivityInfoBase>());
                }
            }
        }
    }