add support for IAsyncDisposable; add test for IDisposable and IAsyncDisposable (#272)

Author: mgravell

docs/releasenotes.md

@@ -1,5 +1,9 @@
 # Release Notes
 
+## unreleased
+
+- improve handling of `IAsyncDisposable`
+
 ## 1.1.1
 
 - update library references

src/protobuf-net.Grpc/Internal/ProxyEmitter.cs

@@ -9,6 +9,7 @@
 using System.Reflection.Emit;
 using System.Runtime.CompilerServices;
 using System.Threading;
+using System.Threading.Tasks;
 
 namespace ProtoBuf.Grpc.Internal
 {
@@ -215,7 +216,18 @@ FieldBuilder Marshaller(Type forType)
                             // it is frequent for some infrastructure code to always call Dispose() on IDisposable,
                             // for instance Asp.Net Core dependency injection, so we don't want to throw in this case
                             if (iType == typeof(IDisposable) && iMethod.Name == nameof(IDisposable.Dispose))
+                            {
                                 il.Emit(OpCodes.Ret);
+                            }
+                            else if (iType == typeof(IAsyncDisposable) && iMethod.Name == nameof(IAsyncDisposable.DisposeAsync))
+                            {
+                                // "return default;"
+                                var loc = il.DeclareLocal(typeof(ValueTask));
+                                il.Emit(OpCodes.Ldloca, loc);
+                                il.Emit(OpCodes.Initobj, typeof(ValueTask));
+                                il.Emit(OpCodes.Ldloc, loc);
+                                il.Emit(OpCodes.Ret);
+                            }
                             else
                                 il.ThrowException(typeof(NotSupportedException));
                             continue;

tests/protobuf-net.Grpc.Test/DisposeTests.cs

@@ -0,0 +1,56 @@
+using Grpc.Core;
+using ProtoBuf.Grpc.Client;
+using ProtoBuf.Grpc.Configuration;
+using System;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace protobuf_net.Grpc.Test
+{
+    public class DisposeTests
+    {
+        [Service]
+        public interface IDisposableService : IDisposable, IAsyncDisposable
+        {}
+
+        [Fact]
+        public void DisposeWorks()
+        {
+            using var client = DummyChannel.Instance.CreateGrpcService<IDisposableService>();
+        }
+
+        [Fact]
+        public async Task DisposeAsyncWorks()
+        {
+            await using var client = DummyChannel.Instance.CreateGrpcService<IDisposableService>();
+        }
+    }
+
+    internal sealed class DummyChannel : ChannelBase
+    {
+        public static DummyChannel Instance { get; } = new();
+        private DummyChannel() : base("") { }
+        public override CallInvoker CreateCallInvoker() => DummyCallInvoker.Instance;
+
+        private sealed class DummyCallInvoker : CallInvoker
+        {
+            public static DummyCallInvoker Instance { get; } = new();
+            private DummyCallInvoker() { }
+
+            public override AsyncClientStreamingCall<TRequest, TResponse> AsyncClientStreamingCall<TRequest, TResponse>(Method<TRequest, TResponse> method, string? host, CallOptions options)
+                => throw new NotSupportedException();
+
+            public override AsyncDuplexStreamingCall<TRequest, TResponse> AsyncDuplexStreamingCall<TRequest, TResponse>(Method<TRequest, TResponse> method, string? host, CallOptions options)
+                => throw new NotSupportedException();
+
+            public override AsyncServerStreamingCall<TResponse> AsyncServerStreamingCall<TRequest, TResponse>(Method<TRequest, TResponse> method, string? host, CallOptions options, TRequest request)
+                => throw new NotSupportedException();
+
+            public override AsyncUnaryCall<TResponse> AsyncUnaryCall<TRequest, TResponse>(Method<TRequest, TResponse> method, string? host, CallOptions options, TRequest request)
+                => throw new NotSupportedException();
+
+            public override TResponse BlockingUnaryCall<TRequest, TResponse>(Method<TRequest, TResponse> method, string? host, CallOptions options, TRequest request)
+                => throw new NotSupportedException();
+        }
+    }
+}