Make ServiceInvoker treat Nullable<T> parameters as a match for null arguments

source/Halibut.TestUtils.CompatBinary.Base/DelegateCountingService.cs

@@ -16,6 +16,11 @@ public int Increment()
             return countingService.Increment();
         }
 
+        public int Increment(int? number)
+        {
+            return countingService.Increment(number);
+        }
+
         public int GetCurrentValue()
         {
             return countingService.GetCurrentValue();

source/Halibut.TestUtils.Contracts/CountingService.cs

@@ -8,7 +8,20 @@ public class CountingService : ICountingService
         int count;
         public int Increment()
         {
-            return Interlocked.Increment(ref count);
+            return Increment(1);
+        }
+
+        public int Increment(int? number)
+        {
+            var increment = number ?? 1;
+            var counter = 0;
+
+            for (var i = 0; i < increment; i++)
+            {
+                counter = Interlocked.Increment(ref count);
+            }
+
+            return counter;
         }
 
         public int GetCurrentValue()
@@ -26,6 +39,12 @@ public async Task<int> IncrementAsync(CancellationToken cancellationToken)
             return service.Increment();
         }
 
+        public async Task<int> IncrementAsync(int? number, CancellationToken cancellationToken)
+        {
+            await Task.CompletedTask;
+            return service.Increment(number);
+        }
+
         public async Task<int> GetCurrentValueAsync(CancellationToken cancellationToken)
         {
             await Task.CompletedTask;

source/Halibut.TestUtils.Contracts/ICountingService.cs

@@ -6,12 +6,14 @@ namespace Halibut.TestUtils.Contracts
     public interface ICountingService
     {
         public int Increment();
+        public int Increment(int? number);
         public int GetCurrentValue();
     }
 
     public interface IAsyncCountingService
     {
         public Task<int> IncrementAsync(CancellationToken cancellationToken);
+        public Task<int> IncrementAsync(int? number, CancellationToken cancellationToken);
         public Task<int> GetCurrentValueAsync(CancellationToken cancellationToken);
     }
 }

source/Halibut.Tests/ServiceModel/ServiceInvokerFixture.cs

@@ -53,6 +53,26 @@ public async Task AsyncInvokeWithNoParamsOnAsyncService()
             response.Result.Should().Be(1);
         }
 
+        [Test]
+        public async Task AsyncInvokeWithNullableParamsOnAsyncService()
+        {
+            var serviceFactory = new ServiceFactoryBuilder()
+                .WithConventionVerificationDisabled()
+                .WithService<ICountingService, IAsyncCountingService>(() => new AsyncCountingService())
+                .Build();
+
+            var sut = new ServiceInvoker(serviceFactory);
+            var request = new RequestMessage()
+            {
+                ServiceName = nameof(ICountingService),
+                MethodName = nameof(ICountingService.Increment),
+                Params = new object[] { null! },
+            };
+
+            var response = await sut.InvokeAsync(request);
+            response.Result.Should().Be(1);
+        }
+
         [Test]
         public async Task AsyncInvokeWithNoParams_AsyncServiceMissingSuffix()
         {

source/Halibut/Portability/TypeExtensions.cs

@@ -17,5 +17,10 @@ public static bool IsValueType(this Type type)
         {
             return type.IsValueType;
         }
+
+        public static bool IsNullable(this Type type)
+        {
+            return !type.IsValueType() || Nullable.GetUnderlyingType(type) != null;
+        }
     }
 }

source/Halibut/ServiceModel/ServiceInvoker.cs

@@ -68,7 +68,7 @@ static MethodInfo SelectAsyncMethod(IList<MethodInfo> methods, RequestMessage re
                 {
                     var paramType = parameters[i].ParameterType;
                     var argType = argumentTypes[i];
-                    if (argType == null && paramType.IsValueType())
+                    if (argType == null && !paramType.IsNullable())
                     {
                         isMatch = false;
                         break;