make binder route all inherited method using the same main service contract name.

Author: Meir Kriheli

src/protobuf-net.Grpc.Reflection/SchemaGenerator.cs

@@ -105,16 +105,14 @@ static Type ApplySubstitutes(Type type)
 
         private static MethodInfo[] GetMethodsRecursively(ServiceBinder serviceBinder, Type contractType)
         {
-            var methods = contractType.GetMethods(BindingFlags.Public | BindingFlags.Instance);
-            var baseContractInterfaces = 
-                contractType.GetInterfaces()
-                .Where(cType => serviceBinder.IsServiceContract(cType, out _)); // only the ones marked as contract type 
+            var includingInheritedInterfaces = ContractOperation.ExpandInterfaces(contractType);
 
-            var inheritedMethods = baseContractInterfaces.SelectMany(cType => GetMethodsRecursively(serviceBinder, cType)).ToArray();
-            if (inheritedMethods.Any())
-                return inheritedMethods.Concat(methods).ToArray();
+            var inheritedMethods = includingInheritedInterfaces
+                .Where(cType => serviceBinder.IsServiceContract(cType, out _)) // only the ones marked as contract type
+                .SelectMany(t => t.GetMethods(BindingFlags.Public | BindingFlags.Instance))
+                .ToArray();
 
-            return methods;
+            return inheritedMethods;
         }
     }
 }

src/protobuf-net.Grpc/Configuration/ServerBinder.cs

@@ -36,16 +36,23 @@ public int Bind(object state, Type serviceType, BinderConfiguration? binderConfi
             int totalCount = 0;
             object?[]? argsBuffer = null;
             Type[] typesBuffer = Array.Empty<Type>();
-            string? serviceName;
-            if (binderConfiguration == null) binderConfiguration = BinderConfiguration.Default;
-            var serviceContracts = typeof(IGrpcService).IsAssignableFrom(serviceType)
-                ? new HashSet<Type> { serviceType }
-                : ContractOperation.ExpandInterfaces(serviceType);
+            
+            binderConfiguration ??= BinderConfiguration.Default;
+
+            if (binderConfiguration.Binder.IsServiceContract(serviceType, out var serviceName) == false)
+            {
+                // TODO: shall we assert the following? (currently it will fail some tests)
+                //throw new ArgumentException($"Type {serviceType.Name} is not defined as contract service", nameof(serviceType));
+            }
+
+            var serviceContracts = ContractOperation.ExpandInterfaces(serviceType);
 
             bool serviceImplSimplifiedExceptions = serviceType.IsDefined(typeof(SimpleRpcExceptionsAttribute));
             foreach (var serviceContract in serviceContracts)
             {
-                if (!binderConfiguration.Binder.IsServiceContract(serviceContract, out serviceName)) continue;
+                // Do not take inherited interfaces names!
+                // The main serviceName will be used as routing identifier to all inherited methods!
+                if (!binderConfiguration.Binder.IsServiceContract(serviceContract, out _)) continue;
 
                 var serviceContractSimplifiedExceptions = serviceImplSimplifiedExceptions || serviceContract.IsDefined(typeof(SimpleRpcExceptionsAttribute));
                 int svcOpCount = 0;

tests/protobuf-net.Grpc.Reflection.Test/SchemaGeneration.cs

@@ -4,9 +4,12 @@
 using ProtoBuf.Grpc.Reflection;
 using System;
 using System.Collections.Generic;
+using System.IO;
+using System.Linq;
 using System.Runtime.Serialization;
-using System.ServiceModel;
 using System.Threading.Tasks;
+using Google.Protobuf.Reflection;
+using Grpc.Core;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -124,7 +127,63 @@ public interface INotAService
             ValueTask NotAServiceAsyncEmpty();
             void NotAServiceSyncEmpty();
         }
+        
+        [Theory]
+        [InlineData(typeof(IMyService))]
+        [InlineData(typeof(IMyInheritedService))]        
+        [InlineData(typeof(IMyAnotherLevelOfInheritedService))]        
+        public void CompareRouteTable(Type type)
+        {
+            // 1: use the existing binder logic to build the routes, using the server logic
+            var binder = new TestBinder();
+            binder.Bind(type, type, BinderConfiguration.Default);
+            var viaBinder = binder.Collect();
+            foreach (var method in viaBinder) Log(method);
+            Log("");
+
+
+            // 2: create a schema and parse it for equivalece
+            var generator = new SchemaGenerator();
+            var schema = generator.GetSchema(type);
+            Log(schema);
+            var fds = new FileDescriptorSet();
+            fds.Add("my.proto", source: new StringReader(schema));
+            fds.Process();
+            Assert.Empty(fds.GetErrors());
+            var viaSchema = new List<string>(viaBinder.Length);
+            var file = fds.Files.Single(static x => x.IncludeInOutput);
+            foreach (var service in file.Services)
+            {
+                var svcName = string.IsNullOrEmpty(file.Package) ? service.Name : $"{file.Package}.{service.Name}";
+                foreach (var method in service.Methods)
+                {
+                    viaSchema.Add($"/{svcName}/{method.Name}");
+                }
+            }
+            viaSchema.Sort();
+
+            Assert.Equal(string.Join(Environment.NewLine, viaBinder), string.Join(Environment.NewLine, viaSchema));
+
+        }
 
+        class TestBinder : ServerBinder
+        {
+            private readonly List<string> _methods = new List<string>();
+            protected override bool TryBind<TService, TRequest, TResponse>(ServiceBindContext bindContext, Method<TRequest, TResponse> method, MethodStub<TService> stub)
+            {
+                _methods.Add(method.FullName);
+                return true;
+            }
+
+            public string[] Collect()
+            {
+                _methods.Sort();
+                var arr = _methods.ToArray();
+                _methods.Clear(); // reset
+                return arr;
+            }
+        }
+        
         [Service]
         public interface ISomeGenericService<in TGenericRequest, TGenericResult>
         {
@@ -143,6 +202,13 @@ public interface IMyInheritedService : IMyService, ISomeGenericService<MyRequest
             void InheritedSyncEmpty();
         }
 
+                
+        [Service]
+        public interface IMyAnotherLevelOfInheritedService : IMyInheritedService
+        {
+            ValueTask<MyResponse> AnotherMethod(MyRequest request, CallContext callContext = default);
+        }
+
         [DataContract]
         public class MyRequest
         {