fixed all unit tests and wired in mediatr

Author: david-driscoll

Common.Build.props

@@ -12,6 +12,8 @@
         <SourceLink_Version>2.8.1</SourceLink_Version>
         <System_Reactive_Version>3.1.1</System_Reactive_Version>
         <MediatR_Version>4.1.0</MediatR_Version>
+        <Autofac_Version>4.8.0</Autofac_Version>
+        <Autofac_Extensions_DependencyInjection_Version>4.2.2</Autofac_Extensions_DependencyInjection_Version>
         <Microsoft_NET_Test_Sdk_Version>15.7.0</Microsoft_NET_Test_Sdk_Version>
         <xunit_Version>2.3.1</xunit_Version>
         <FluentAssertions_Version>5.3.0</FluentAssertions_Version>

src/JsonRpc/EmptyRequest.cs

@@ -0,0 +1,10 @@
+using MediatR;
+
+namespace OmniSharp.Extensions.JsonRpc
+{
+    public class EmptyRequest : IRequest
+    {
+        private EmptyRequest() { }
+        public static EmptyRequest Instance { get; } = new EmptyRequest();
+    }
+}

src/JsonRpc/HandlerCollection.cs

@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using MediatR;
 
 namespace OmniSharp.Extensions.JsonRpc
 {
@@ -14,19 +15,21 @@ internal class HandlerInstance : IHandlerDescriptor, IDisposable
         {
             private readonly Action _disposeAction;
 
-            public HandlerInstance(string method, IJsonRpcHandler handler, Type handlerInterface, Type @params, Action disposeAction)
+            public HandlerInstance(string method, IJsonRpcHandler handler, Type handlerInterface, Type @params, Type response, Action disposeAction)
             {
                 _disposeAction = disposeAction;
                 Handler = handler;
                 Method = method;
                 HandlerType = handlerInterface;
                 Params = @params;
+                Response = response;
             }
 
             public IJsonRpcHandler Handler { get; }
             public Type HandlerType { get; }
             public string Method { get; }
             public Type Params { get; }
+            public Type Response { get; }
 
             public void Dispose()
             {
@@ -61,12 +64,17 @@ public IDisposable Add(string method, IJsonRpcHandler handler)
             var @interface = GetHandlerInterface(type);
 
             Type @params = null;
+            Type response = null;
             if (@interface.GetTypeInfo().IsGenericType)
             {
                 @params = @interface.GetTypeInfo().GetGenericArguments()[0];
+                var requestInterface = @params.GetInterfaces()
+                    .FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IRequest<>));
+                if (requestInterface != null)
+                    response = requestInterface.GetGenericArguments()[0];
             }
 
-            var h = new HandlerInstance(method, handler, @interface, @params, () => Remove(handler));
+            var h = new HandlerInstance(method, handler, @interface, @params, response, () => Remove(handler));
             _handlers.Add(h);
             return h;
         }

src/JsonRpc/IHandlerDescriptor.cs

@@ -8,5 +8,6 @@ public interface IHandlerDescriptor
         IJsonRpcHandler Handler { get; }
         Type HandlerType { get; }
         Type Params { get; }
+        Type Response { get; }
     }
 }

src/JsonRpc/IJsonRpcNotificationHandler.cs

@@ -3,7 +3,7 @@
 
 namespace OmniSharp.Extensions.JsonRpc
 {
-    public interface IJsonRpcNotificationHandler : IRequestHandler<IRequest>, IJsonRpcHandler { }
+    public interface IJsonRpcNotificationHandler : IRequestHandler<EmptyRequest>, IJsonRpcHandler { }
 
     public interface IJsonRpcNotificationHandler<in TNotification> : IRequestHandler<TNotification>, IJsonRpcHandler
         where TNotification : IRequest

src/JsonRpc/IReciever.cs

@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using Newtonsoft.Json.Linq;
 using OmniSharp.Extensions.JsonRpc.Server;
 
@@ -9,4 +9,4 @@ public interface IReciever
         (IEnumerable<Renor> results, bool hasResponse) GetRequests(JToken container);
         bool IsValid(JToken container);
     }
-}
+}

src/JsonRpc/IRequestContext.cs

@@ -0,0 +1,7 @@
+namespace OmniSharp.Extensions.JsonRpc
+{
+    public interface IRequestContext
+    {
+        IHandlerDescriptor Descriptor { get; set; }
+    }
+}

src/JsonRpc/JsonRpc.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
         <TargetFrameworks>netstandard2.0</TargetFrameworks>
         <PlatformTarget>AnyCPU</PlatformTarget>
@@ -9,5 +9,7 @@
         <PackageReference Include="MediatR" Version="$(MediatR_Version)" />
         <PackageReference Include="Newtonsoft.Json" Version="$(Newtonsoft_Version)" />
         <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="$(Microsoft_Extensions_Logging_Version)" />
+        <PackageReference Include="MediatR.Extensions.Microsoft.DependencyInjection" Version="$(MediatR_Version)" />
+        <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="$(Microsoft_Extensions_DependencyInjection_Version)" />
     </ItemGroup>
 </Project>

src/JsonRpc/ReflectionRequestHandlers.cs

@@ -1,3 +1,4 @@
+using System.Linq;
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
@@ -8,36 +9,50 @@ namespace OmniSharp.Extensions.JsonRpc
 {
     public static class MediatRHandlers
     {
-        private static readonly MethodInfo PublishNotificationMethod = typeof(MediatRHandlers)
-            .GetMethod(nameof(PublishNotification), BindingFlags.NonPublic | BindingFlags.Static);
+        private static readonly MethodInfo SendRequestUnit = typeof(MediatRHandlers)
+            .GetMethods(BindingFlags.NonPublic | BindingFlags.Static)
+            .Where(x => x.Name == nameof(SendRequest))
+            .First(x => x.GetGenericArguments().Length == 1);
 
-        private static readonly MethodInfo SendRequestMethod = typeof(MediatRHandlers)
-            .GetMethod(nameof(SendRequest), BindingFlags.NonPublic | BindingFlags.Static);
+        private static readonly MethodInfo SendRequestResponse = typeof(MediatRHandlers)
+            .GetMethods(BindingFlags.NonPublic | BindingFlags.Static)
+            .Where(x => x.Name == nameof(SendRequest))
+            .First(x => x.GetGenericArguments().Length == 2);
 
         public static Task HandleNotification(IMediator mediator, IHandlerDescriptor handler, object @params, CancellationToken token)
         {
-            return (Task)PublishNotificationMethod
-                .MakeGenericMethod(handler.Params ?? typeof(INotification))
+            return (Task)SendRequestUnit
+                .MakeGenericMethod(handler.Params ?? typeof(EmptyRequest))
                 .Invoke(null, new object[] { mediator, @params, token });
         }
 
-        private static Task PublishNotification<T>(IMediator mediator, T notification, CancellationToken token)
-            where T : INotification
-        {
-            return mediator.Publish(notification, token);
-        }
-
         public static Task HandleRequest(IMediator mediator, IHandlerDescriptor handler, object @params, CancellationToken token)
         {
-            return (Task)SendRequestMethod
-                .MakeGenericMethod(handler.Params ?? typeof(INotification))
-                .Invoke(null, new object[] { mediator, @params, token });
+            if (handler.HandlerType.GetInterfaces().Any(x =>
+                x.IsGenericType && typeof(IRequestHandler<>).IsAssignableFrom(x.GetGenericTypeDefinition())))
+            {
+                return (Task)SendRequestUnit
+                    .MakeGenericMethod(handler.Params)
+                    .Invoke(null, new object[] { mediator, @params, token });
+            }
+            else
+            {
+                return (Task)SendRequestResponse
+                    .MakeGenericMethod(handler.Params, handler.Response)
+                    .Invoke(null, new object[] { mediator, @params, token });
+            }
         }
 
         private static Task SendRequest<T>(IMediator mediator, T request, CancellationToken token)
             where T : IRequest
         {
             return mediator.Send(request, token);
         }
+
+        private static Task<TResponse> SendRequest<T, TResponse>(IMediator mediator, T request, CancellationToken token)
+            where T : IRequest<TResponse>
+        {
+            return mediator.Send(request, token);
+        }
     }
 }

src/JsonRpc/RequestContext.cs

@@ -0,0 +1,7 @@
+namespace OmniSharp.Extensions.JsonRpc
+{
+    class RequestContext : IRequestContext
+    {
+        public IHandlerDescriptor Descriptor { get; set; }
+    }
+}