moved to observables for events

Author: david-driscoll

src/Client/LanguageClient.cs

@@ -92,7 +92,7 @@ public LanguageClient(ILoggerFactory loggerFactory, ServerProcess process)
                 throw new ArgumentNullException(nameof(process));
 
             _process = process;
-            _process.Exited += ServerProcess_Exit;
+            _process.Exited.Subscribe(x => ServerProcess_Exit());
         }
 
         /// <summary>
@@ -452,7 +452,7 @@ async Task Start()
         /// <param name="args">
         ///     The event arguments.
         /// </param>
-        async void ServerProcess_Exit(object sender, EventArgs args)
+        async void ServerProcess_Exit()
         {
             Log.LogDebug("Server process has exited; language client is shutting down...");
 

src/Client/Processes/ServerProcess.cs

@@ -1,5 +1,7 @@
-using System;
+using System;
 using System.IO;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 
@@ -11,6 +13,7 @@ namespace OmniSharp.Extensions.LanguageServer.Client.Processes
     public abstract class ServerProcess
         : IDisposable
     {
+        private readonly ISubject<object> _exitedSubject;
         /// <summary>
         ///     Create a new <see cref="ServerProcess"/>.
         /// </summary>
@@ -31,6 +34,8 @@ protected ServerProcess(ILoggerFactory loggerFactory)
 
             ServerExitCompletion = new TaskCompletionSource<object>();
             ServerExitCompletion.SetResult(null); // Start out as if the server has already exited.
+
+            Exited = _exitedSubject = new AsyncSubject<object>();
         }
 
         /// <summary>
@@ -82,7 +87,7 @@ protected virtual void Dispose(bool disposing)
         /// <summary>
         ///     Event raised when the server has exited.
         /// </summary>
-        public event EventHandler<EventArgs> Exited;
+        public IObservable<object> Exited { get; }
 
         /// <summary>
         ///     Is the server running?
@@ -130,7 +135,8 @@ protected virtual void Dispose(bool disposing)
         /// </summary>
         protected virtual void OnExited()
         {
-            Exited?.Invoke(this, EventArgs.Empty);
+            _exitedSubject.OnNext(null);
+            _exitedSubject.OnCompleted();
         }
     }
 }

src/Server/Handlers/ExitEventHandler.cs

@@ -1,3 +1,6 @@
+using System;
+using System.Reactive.Subjects;
+using System.Reactive.Threading.Tasks;
 using System.Threading;
 using System.Threading.Tasks;
 using MediatR;
@@ -9,25 +12,26 @@ namespace OmniSharp.Extensions.LanguageServer.Server.Handlers
 {
     public class ExitHandler : IExitHandler
     {
+        private readonly ISubject<int> _exitSubject;
         private readonly ShutdownHandler _shutdownHandler;
 
         public ExitHandler(ShutdownHandler shutdownHandler)
         {
             _shutdownHandler = shutdownHandler;
+            Exit = _exitSubject = new AsyncSubject<int>();
         }
 
-        private readonly TaskCompletionSource<int> _exitedSource = new TaskCompletionSource<int>(TaskContinuationOptions.LongRunning);
-        public Task WaitForExit => _exitedSource.Task;
+        public Task WaitForExit => Exit.ToTask();
+        public IObservable<int> Exit { get; }
 
 
-        public Task Handle(EmptyRequest request, CancellationToken token)
+        public async Task Handle(EmptyRequest request, CancellationToken token)
         {
+            await Task.Yield();
+
             var result = _shutdownHandler.ShutdownRequested ? 0 : 1;
-            Exit?.Invoke(result);
-            _exitedSource.SetResult(result);
-            return Task.CompletedTask;
+            _exitSubject.OnNext(result);
+            _exitSubject.OnCompleted();
         }
-
-        public event ExitEventHandler Exit;
     }
 }

src/Server/Handlers/ExitHandler.cs

@@ -1,3 +1,7 @@
+using System;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using System.Reactive.Threading.Tasks;
 using System.Threading;
 using System.Threading.Tasks;
 using MediatR;
@@ -9,24 +13,29 @@ namespace OmniSharp.Extensions.LanguageServer.Server.Handlers
 {
     public class ShutdownHandler : IShutdownHandler
     {
-        public event ShutdownEventHandler Shutdown;
+        private readonly ISubject<bool> _shutdownSubject;
 
+        public ShutdownHandler()
+        {
+            Shutdown = _shutdownSubject = new AsyncSubject<bool>();
+        }
+
+        public IObservable<bool> Shutdown { get; }
         public bool ShutdownRequested { get; private set; }
+        public Task WasShutDown => Shutdown.ToTask();
 
-        private readonly TaskCompletionSource<bool> _shutdownSource = new TaskCompletionSource<bool>(TaskContinuationOptions.LongRunning);
-        public Task WasShutDown => _shutdownSource.Task;
         public async Task Handle(EmptyRequest request, CancellationToken token)
         {
             await Task.Yield(); // Ensure shutdown handler runs asynchronously.
 
             ShutdownRequested = true;
             try
             {
-                Shutdown?.Invoke(ShutdownRequested);
+                _shutdownSubject.OnNext(ShutdownRequested);
             }
             finally
             {
-                _shutdownSource.SetResult(true); // after all event sinks were notified
+                _shutdownSubject.OnCompleted();
             }
         }
     }

src/Server/Handlers/ShutdownEventHandler.cs

@@ -19,8 +19,8 @@ public interface ILanguageServer : IResponseRouter, IDisposable
 
         Task Initialize();
 
-        event ShutdownEventHandler Shutdown;
-        event ExitEventHandler Exit;
+        IObservable<bool> Shutdown { get; }
+        IObservable<int> Exit { get; }
         Task WasShutDown { get; }
         Task WaitForExit { get; }
     }

src/Server/Handlers/ShutdownHandler.cs

@@ -365,17 +365,8 @@ private async Task DynamicallyRegisterHandlers()
             await this.RegisterCapability(@params);
         }
 
-        public event ShutdownEventHandler Shutdown
-        {
-            add => _shutdownHandler.Shutdown += value;
-            remove => _shutdownHandler.Shutdown -= value;
-        }
-
-        public event ExitEventHandler Exit
-        {
-            add => _exitHandler.Exit += value;
-            remove => _exitHandler.Exit -= value;
-        }
+        public IObservable<bool> Shutdown => _shutdownHandler.Shutdown;
+        public IObservable<int> Exit => _exitHandler.Exit;
 
         public void SendNotification<T>(string method, T @params)
         {

src/Server/ILanguageServer.cs

@@ -212,9 +212,9 @@ public async Task ShouldHandle_Request_WithNullParameters()
             bool wasShutDown = false;
 
             var shutdownHandler = new ShutdownHandler();
-            shutdownHandler.Shutdown += shutdownRequested => {
+            shutdownHandler.Shutdown .Subscribe(shutdownRequested => {
                 wasShutDown = true;
-            };
+            });
 
             var collection = new HandlerCollection { shutdownHandler };
             AutoSubstitute.Provide<IHandlerCollection>(collection);
@@ -235,9 +235,9 @@ public async Task ShouldHandle_Request_WithMissingParameters()
         {
             bool wasShutdown = false;
             var shutdownHandler = new ShutdownHandler();
-            shutdownHandler.Shutdown += shutdownRequested => {
+            shutdownHandler.Shutdown .Subscribe(shutdownRequested => {
                 wasShutdown = true;
-            };
+            });
 
             var collection = new HandlerCollection { shutdownHandler };
             AutoSubstitute.Provide<IHandlerCollection>(collection);