Better way to handle notifications

Author: shana

src/GitHub.Exports.Reactive/Services/NotificationDispatcher.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.ComponentModel.Composition;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
@@ -12,39 +13,66 @@ namespace GitHub.Services
     public sealed class NotificationDispatcher : INotificationDispatcher, IDisposable
     {
         Subject<Notification> notifications;
+        Stack<INotificationService> notificationHandlers;
 
         public NotificationDispatcher()
         {
             notifications = new Subject<Notification>();
+            notificationHandlers = new Stack<INotificationService>();
         }
 
         public IObservable<Notification> Listen()
         {
             return notifications;
         }
 
+        public void AddListener(INotificationService handler)
+        {
+            notificationHandlers.Push(handler);
+        }
+
+        public void RemoveListener()
+        {
+            notificationHandlers.Pop();
+        }
+
+        public void RemoveListener(INotificationService handler)
+        {
+            Stack<INotificationService> handlers = new Stack<INotificationService>();
+            while(notificationHandlers.TryPeek() != handler)
+                handlers.Push(notificationHandlers.Pop());
+            if (notificationHandlers.Count > 0)
+                notificationHandlers.Pop();
+            while (handlers.Count > 0)
+                notificationHandlers.Push(handlers.Pop());
+        }
+
         public void ShowMessage(string message)
         {
             notifications.OnNext(new Notification(message, Notification.NotificationType.Message));
+            var handler = notificationHandlers.TryPeek();
+            handler?.ShowMessage(message);
         }
 
         public void ShowMessage(string message, ICommand command)
         {
             notifications.OnNext(new Notification(message, Notification.NotificationType.Message, command));
+            var handler = notificationHandlers.TryPeek();
+            handler?.ShowMessage(message, command);
         }
 
         public void ShowWarning(string message)
         {
             notifications.OnNext(new Notification(message, Notification.NotificationType.Warning));
+            var handler = notificationHandlers.TryPeek();
+            handler.ShowWarning(message);
         }
 
         public void ShowError(string message)
         {
             notifications.OnNext(new Notification(message, Notification.NotificationType.Error));
-        }
-
-        public void ClearNotifications()
-        {
+            var handler = notificationHandlers.TryPeek();
+            handler?.ShowError(message);
         }
 
         bool disposed; // To detect redundant calls

src/GitHub.Exports/Services/INotificationDispatcher.cs

@@ -27,5 +27,8 @@ public Notification(string message, NotificationType type, ICommand command = nu
     public interface INotificationDispatcher : INotificationService
     {
         IObservable<Notification> Listen();
+        void AddListener(INotificationService notificationHandler);
+        void RemoveListener();
+        void RemoveListener(INotificationService notificationHandler);
     }
 }

src/GitHub.Exports/Services/INotificationService.cs

@@ -8,6 +8,5 @@ public interface INotificationService
         void ShowMessage(string message, ICommand command);
         void ShowWarning(string message);
         void ShowError(string message);
-        void ClearNotifications();
     }
 }

src/GitHub.Exports/Services/ITeamExplorerServices.cs

@@ -4,5 +4,6 @@ namespace GitHub.Services
 {
     public interface ITeamExplorerServices : INotificationService
     {
+        void ClearNotifications();
     }
 }

src/GitHub.Extensions/EnumerableExtensions.cs

@@ -21,5 +21,14 @@ public static IEnumerable<TSource> Except<TSource>(
 
     }
 
+    public static class StackExtensions
+    {
+        public static T TryPeek<T>(this Stack<T> stack) where T : class
+        {
+            if (stack.Count > 0)
+                return stack.Peek();
+            return default(T);
+        }
+    }
 }