Use <DebugAction>HandlerBase ABCs instead of interfaces

Author: andyleejordan

src/PowerShellEditorServices/Server/PsesDebugServer.cs

@@ -81,7 +81,11 @@ public async Task StartAsync()
                     .WithHandler<StackTraceHandler>()
                     .WithHandler<ScopesHandler>()
                     .WithHandler<VariablesHandler>()
-                    .WithHandler<DebuggerActionHandlers>()
+                    .WithHandler<ContinueHandler>()
+                    .WithHandler<NextHandler>()
+                    .WithHandler<PauseHandler>()
+                    .WithHandler<StepInHandler>()
+                    .WithHandler<StepOutHandler>()
                     .WithHandler<SourceHandler>()
                     .WithHandler<SetVariableHandler>()
                     .WithHandler<DebugEvaluateHandler>()

src/PowerShellEditorServices/Services/DebugAdapter/Handlers/DebuggerActionHandlers.cs

@@ -4,59 +4,78 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Extensions.Logging;
 using Microsoft.PowerShell.EditorServices.Services;
 using OmniSharp.Extensions.DebugAdapter.Protocol.Requests;
 using OmniSharp.Extensions.JsonRpc;
 
 namespace Microsoft.PowerShell.EditorServices.Handlers
 {
-    // TODO: Inherit from ABCs instead of satisfying interfaces.
-    internal class DebuggerActionHandlers : IContinueHandler, INextHandler, IPauseHandler, IStepInHandler, IStepOutHandler
+    internal class ContinueHandler : ContinueHandlerBase
     {
-        private readonly ILogger _logger;
         private readonly DebugService _debugService;
 
-        public DebuggerActionHandlers(
-            ILoggerFactory loggerFactory,
-            DebugService debugService)
-        {
-            _logger = loggerFactory.CreateLogger<ContinueHandlerBase>();
-            _debugService = debugService;
-        }
+        public ContinueHandler(DebugService debugService) => _debugService = debugService;
 
-        public Task<ContinueResponse> Handle(ContinueArguments request, CancellationToken cancellationToken)
+        public override Task<ContinueResponse> Handle(ContinueArguments request, CancellationToken cancellationToken)
         {
             _debugService.Continue();
             return Task.FromResult(new ContinueResponse());
         }
+    }
+
+    internal class NextHandler : NextHandlerBase
+    {
+        private readonly DebugService _debugService;
 
-        public Task<NextResponse> Handle(NextArguments request, CancellationToken cancellationToken)
+        public NextHandler(DebugService debugService) => _debugService = debugService;
+
+        public override Task<NextResponse> Handle(NextArguments request, CancellationToken cancellationToken)
         {
             _debugService.StepOver();
             return Task.FromResult(new NextResponse());
         }
+    }
+
+    internal class PauseHandler : PauseHandlerBase
+    {
+        private readonly DebugService _debugService;
 
-        public Task<PauseResponse> Handle(PauseArguments request, CancellationToken cancellationToken)
+        public PauseHandler(DebugService debugService) => _debugService = debugService;
+
+        public override Task<PauseResponse> Handle(PauseArguments request, CancellationToken cancellationToken)
         {
             try
             {
                 _debugService.Break();
                 return Task.FromResult(new PauseResponse());
             }
-            catch(NotSupportedException e)
+            catch (NotSupportedException e)
             {
                 throw new RpcErrorException(0, e.Message);
             }
         }
+    }
+
+    internal class StepInHandler : StepInHandlerBase
+    {
+        private readonly DebugService _debugService;
+
+        public StepInHandler(DebugService debugService) => _debugService = debugService;
 
-        public Task<StepInResponse> Handle(StepInArguments request, CancellationToken cancellationToken)
+        public override Task<StepInResponse> Handle(StepInArguments request, CancellationToken cancellationToken)
         {
             _debugService.StepIn();
             return Task.FromResult(new StepInResponse());
         }
+    }
+
+    internal class StepOutHandler : StepOutHandlerBase
+    {
+        private readonly DebugService _debugService;
+
+        public StepOutHandler(DebugService debugService) => _debugService = debugService;
 
-        public Task<StepOutResponse> Handle(StepOutArguments request, CancellationToken cancellationToken)
+        public override Task<StepOutResponse> Handle(StepOutArguments request, CancellationToken cancellationToken)
         {
             _debugService.StepOut();
             return Task.FromResult(new StepOutResponse());