Per service contract, we will collect all the methods of inherited interfaces

and bind them as they were defined in the service contract itself.
(their binding key will be based on the service contract and not based on the base-interfaces).

Author: Meir Kriheli

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

@@ -105,10 +105,9 @@ static Type ApplySubstitutes(Type type)
 
         private static MethodInfo[] GetMethodsRecursively(ServiceBinder serviceBinder, Type contractType)
         {
-            var includingInheritedInterfaces = ContractOperation.ExpandInterfaces(contractType);
+            var includingInheritedInterfaces = ContractOperation.ExpandWithInterfacesMarkedAsServiceInheritable(contractType);
 
             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();
 

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

@@ -24,57 +24,74 @@ are observed and respected
         /// <summary>
         /// Initiate a bind operation, causing all service methods to be crawled for the provided type
         /// </summary>
-        public int Bind<TService>(object state, BinderConfiguration? binderConfiguration = null, TService? service = null)
+        public int Bind<TService>(object state, BinderConfiguration? binderConfiguration = null,
+            TService? service = null)
             where TService : class
             => Bind(state, typeof(TService), binderConfiguration, service);
 
         /// <summary>
         /// Initiate a bind operation, causing all service methods to be crawled for the provided type
         /// </summary>
-        public int Bind(object state, Type serviceType, BinderConfiguration? binderConfiguration = null, object? service = null)
+        public int Bind(object state, Type serviceType, BinderConfiguration? binderConfiguration = null,
+            object? service = null)
         {
             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 }
+                ? new HashSet<Type> {serviceType}
                 : ContractOperation.ExpandInterfaces(serviceType);
 
             bool serviceImplSimplifiedExceptions = serviceType.IsDefined(typeof(SimpleRpcExceptionsAttribute));
             foreach (var serviceContract in serviceContracts)
             {
-                if (!binderConfiguration.Binder.IsServiceContract(serviceContract, out serviceName)) continue;
+                if (!binderConfiguration.Binder.IsServiceContract(serviceContract, out var serviceName)) continue;
+
+                var typesToBeIncludedInMethodsBinding =
+                    ContractOperation.ExpandWithInterfacesMarkedAsServiceInheritable(serviceContract);
+
+                // Per service contract, we will collect all the methods of inherited interfaces
+                // and bind them as they were defined in the service contract itself.
+                // (their binding key will be based on the service contract and not based on the base-interfaces).
 
-                var serviceContractSimplifiedExceptions = serviceImplSimplifiedExceptions || serviceContract.IsDefined(typeof(SimpleRpcExceptionsAttribute));
                 int svcOpCount = 0;
-                var bindCtx = new ServiceBindContext(serviceContract, serviceType, state, binderConfiguration.Binder);
-                foreach (var op in ContractOperation.FindOperations(binderConfiguration, serviceContract, this))
+                foreach (var typeToBindItsMethods in typesToBeIncludedInMethodsBinding)
                 {
-                    if (ServerInvokerLookup.TryGetValue(op.MethodType, op.Context, op.Result, op.Void, out var invoker)
-                        && AddMethod(op.From, op.To, op.Name, op.Method, op.MethodType, invoker, bindCtx,
-                        serviceContractSimplifiedExceptions || op.Method.IsDefined(typeof(SimpleRpcExceptionsAttribute))
-                        ))
+                    var serviceContractSimplifiedExceptions = serviceImplSimplifiedExceptions ||
+                                                              typeToBindItsMethods.IsDefined(
+                                                                  typeof(SimpleRpcExceptionsAttribute));
+                    var bindCtx = new ServiceBindContext(serviceContract, serviceType, state, binderConfiguration.Binder);
+                    foreach (var op in ContractOperation.FindOperations(binderConfiguration, typeToBindItsMethods, this))
                     {
-                        // yay!
-                        totalCount++;
-                        svcOpCount++;
+                        if (ServerInvokerLookup.TryGetValue(op.MethodType, op.Context, op.Result, op.Void, out var invoker)
+                            && AddMethod(serviceName, op.From, op.To, op.Name, op.Method, op.MethodType, invoker, bindCtx,
+                                serviceContractSimplifiedExceptions || op.Method.IsDefined(typeof(SimpleRpcExceptionsAttribute))
+                            ))
+                        {
+                            // yay!
+                            totalCount++;
+                            svcOpCount++;
+                        }
                     }
                 }
+
                 OnServiceBound(state, serviceName!, serviceType, serviceContract, svcOpCount);
             }
+
             return totalCount;
 
-            bool AddMethod(Type @in, Type @out, string on, MethodInfo m, MethodType t,
-                Func<MethodInfo, ParameterExpression[], Expression>? invoker, ServiceBindContext bindContext, bool simplifiedExceptionHandling)
+            bool AddMethod(string? serviceName, Type @in, Type @out, string on, MethodInfo m, MethodType t,
+                Func<MethodInfo, ParameterExpression[], Expression>? invoker, ServiceBindContext bindContext,
+                bool simplifiedExceptionHandling)
             {
                 try
                 {
                     if (typesBuffer.Length == 0)
                     {
-                        typesBuffer = new Type[] { serviceType, typeof(void), typeof(void) };
+                        typesBuffer = new Type[] {serviceType, typeof(void), typeof(void)};
                     }
+
                     typesBuffer[1] = @in;
                     typesBuffer[2] = @out;
 
@@ -84,6 +101,7 @@ bool AddMethod(Type @in, Type @out, string on, MethodInfo m, MethodType t,
                         argsBuffer[6] = binderConfiguration!.MarshallerCache;
                         argsBuffer[7] = service is null ? null : Expression.Constant(service, serviceType);
                     }
+
                     argsBuffer[0] = serviceName;
                     argsBuffer[1] = on;
                     argsBuffer[2] = m;
@@ -93,7 +111,7 @@ bool AddMethod(Type @in, Type @out, string on, MethodInfo m, MethodType t,
                     // 6, 7 set during array initialization
                     argsBuffer[8] = simplifiedExceptionHandling;
 
-                    return (bool)s_addMethod.MakeGenericMethod(typesBuffer).Invoke(this, argsBuffer)!;
+                    return (bool) s_addMethod.MakeGenericMethod(typesBuffer).Invoke(this, argsBuffer)!;
                 }
                 catch (Exception fail)
                 {
@@ -106,7 +124,10 @@ bool AddMethod(Type @in, Type @out, string on, MethodInfo m, MethodType t,
         /// <summary>
         /// Reports the number of operations available for a service
         /// </summary>
-        protected virtual void OnServiceBound(object state, string serviceName, Type serviceType, Type serviceContract, int operationCount) { }
+        protected virtual void OnServiceBound(object state, string serviceName, Type serviceType, Type serviceContract,
+            int operationCount)
+        {
+        }
 
         private static readonly MethodInfo s_addMethod = typeof(ServerBinder).GetMethod(
             nameof(AddMethod), BindingFlags.Instance | BindingFlags.NonPublic)!;
@@ -133,7 +154,8 @@ protected readonly struct MethodStub<TService>
             /// </summary>
             public MethodInfo Method { get; }
 
-            internal MethodStub(Func<MethodInfo, Expression[], Expression>? invoker, MethodInfo method, ConstantExpression? service, bool simpleExceptionHandling)
+            internal MethodStub(Func<MethodInfo, Expression[], Expression>? invoker, MethodInfo method,
+                ConstantExpression? service, bool simpleExceptionHandling)
             {
                 _simpleExceptionHandling = simpleExceptionHandling;
                 _invoker = invoker;
@@ -163,7 +185,7 @@ public TDelegate CreateDelegate<TDelegate>()
                     else
                     {
                         // basic - direct call
-                        return (TDelegate)Delegate.CreateDelegate(typeof(TDelegate), _service, Method);
+                        return (TDelegate) Delegate.CreateDelegate(typeof(TDelegate), _service, Method);
                     }
                 }
                 else
@@ -172,7 +194,8 @@ public TDelegate CreateDelegate<TDelegate>()
 
                     Expression[] mapArgs;
                     if (_service is null)
-                    {   // if no service object, then the service is part of the signature, i.e. (svc, req) => svc.Blah();
+                    {
+                        // if no service object, then the service is part of the signature, i.e. (svc, req) => svc.Blah();
                         mapArgs = lambdaArgs;
                     }
                     else
@@ -189,6 +212,7 @@ public TDelegate CreateDelegate<TDelegate>()
                     {
                         body = ApplySimpleExceptionHandling(body);
                     }
+
                     var lambda = Expression.Lambda<TDelegate>(body, lambdaArgs);
 
                     return lambda.Compile();
@@ -204,17 +228,19 @@ static Expression ApplySimpleExceptionHandling(Expression body)
                 }
                 else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Task<>))
                 {
-                    body = Expression.Call(s_ReshapeWithSimpleExceptionHandling[1].MakeGenericMethod(type.GetGenericArguments()), body);
+                    body = Expression.Call(
+                        s_ReshapeWithSimpleExceptionHandling[1].MakeGenericMethod(type.GetGenericArguments()), body);
                 }
+
                 return body;
             }
         }
 
 #pragma warning disable CS0618
         private static readonly Dictionary<int, MethodInfo> s_ReshapeWithSimpleExceptionHandling =
             (from method in typeof(Reshape).GetMethods(BindingFlags.Public | BindingFlags.Static)
-             where method.Name is nameof(Reshape.WithSimpleExceptionHandling)
-             select method)
+                where method.Name is nameof(Reshape.WithSimpleExceptionHandling)
+                select method)
             .ToDictionary(method => method.IsGenericMethodDefinition ? method.GetGenericArguments().Length : 0);
 #pragma warning restore CS0618
 
@@ -227,7 +253,8 @@ private bool AddMethod<TService, TRequest, TResponse>(
             where TRequest : class
             where TResponse : class
         {
-            var grpcMethod = new Method<TRequest, TResponse>(methodType, serviceName, operationName, marshallerCache.GetMarshaller<TRequest>(), marshallerCache.GetMarshaller<TResponse>());
+            var grpcMethod = new Method<TRequest, TResponse>(methodType, serviceName, operationName,
+                marshallerCache.GetMarshaller<TRequest>(), marshallerCache.GetMarshaller<TResponse>());
             var stub = new MethodStub<TService>(invoker, method, service, simplfiedExceptionHandling);
             try
             {
@@ -238,13 +265,13 @@ private bool AddMethod<TService, TRequest, TResponse>(
                 OnError(ex.Message);
                 return false;
             }
-
         }
 
         /// <summary>
         /// The implementing binder should bind the method to the bind-state
         /// </summary>
-        protected abstract bool TryBind<TService, TRequest, TResponse>(ServiceBindContext bindContext, Method<TRequest, TResponse> method, MethodStub<TService> stub)
+        protected abstract bool TryBind<TService, TRequest, TResponse>(ServiceBindContext bindContext,
+            Method<TRequest, TResponse> method, MethodStub<TService> stub)
             where TService : class
             where TRequest : class
             where TResponse : class;
@@ -255,12 +282,16 @@ protected abstract bool TryBind<TService, TRequest, TResponse>(ServiceBindContex
         /// <summary>
         /// Publish a warning message
         /// </summary>
-        protected internal virtual void OnWarn(string message, object?[]? args = null) { }
+        protected internal virtual void OnWarn(string message, object?[]? args = null)
+        {
+        }
 
         /// <summary>
         /// Publish a warning message
         /// </summary>
-        protected internal virtual void OnError(string message, object?[]? args = null) { }
+        protected internal virtual void OnError(string message, object?[]? args = null)
+        {
+        }
 
         /// <summary>
         /// Describes the relationship between a service contract and a service definition
@@ -304,4 +335,4 @@ public IList<object> GetMetadata(MethodInfo method)
                 => ServiceBinder.GetMetadata(method, ContractType, ServiceType);
         }
     }
-}
+}

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

@@ -0,0 +1,15 @@
+using System;
+using System.ComponentModel;
+
+namespace ProtoBuf.Grpc.Configuration
+{
+    /// <summary>
+    /// Indicates that this interface can be inherited by a gRPC service.
+    /// All methods of this interface will be routed based on inherited service name.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Interface, AllowMultiple = false, Inherited = false)]
+    [ImmutableObject(true)]
+    public sealed class ServiceInheritableAttribute : Attribute
+    {
+    }
+}

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

@@ -363,6 +363,29 @@ internal static ISet<Type> ExpandInterfaces(Type type)
             if (type.IsInterface) set.Add(type);
             return set;
         }
+        
+        /// <summary>
+        /// Collect all the types to be used for extracting methods for a specific Service Contract
+        /// </summary>
+        /// <param name="serviceContract">Must be a service contract</param>
+        /// <returns>types to be used for extracting methods</returns>
+        internal static ISet<Type> ExpandWithInterfacesMarkedAsServiceInheritable(Type serviceContract)
+        {
+            var set = new HashSet<Type>();
+            
+            // first add the service contract by itself 
+            set.Add(serviceContract); 
+
+            // now add all inherited interfaces which are marked as inheritable
+            foreach (var t in serviceContract.GetInterfaces())
+            {
+                if (t.IsDefined(typeof(ServiceInheritableAttribute)))
+                {
+                    set.Add(t);
+                }
+            }
+            return set;
+        }
     }
 
     internal enum ContextKind

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

@@ -59,7 +59,7 @@ service MyService {
         }
 
         [Fact]
-        public void CheckIngeritedInterfaceSchema()
+        public void CheckInheritedInterfaceSchema()
         {
             var generator = new SchemaGenerator();
             var schema = generator.GetSchema<IMyInheritedService>();
@@ -84,19 +84,13 @@ message MyResponse {
    string RefId = 3; // default value could not be applied: 00000000-0000-0000-0000-000000000000
 }
 service MyInheritedService {
-   rpc AsyncEmpty (.google.protobuf.Empty) returns (.google.protobuf.Empty);
-   rpc ClientStreaming (stream MyRequest) returns (MyResponse);
-   rpc FullDuplex (stream MyRequest) returns (stream MyResponse);
    rpc GenericUnary (MyRequest) returns (MyResponse);
    rpc InheritedAsyncEmpty (.google.protobuf.Empty) returns (.google.protobuf.Empty);
    rpc InheritedClientStreaming (stream MyRequest) returns (MyResponse);
    rpc InheritedFullDuplex (stream MyRequest) returns (stream MyResponse);
    rpc InheritedServerStreaming (MyRequest) returns (stream MyResponse);
    rpc InheritedSyncEmpty (.google.protobuf.Empty) returns (.google.protobuf.Empty);
    rpc InheritedUnary (MyRequest) returns (MyResponse);
-   rpc ServerStreaming (MyRequest) returns (stream MyResponse);
-   rpc SyncEmpty (.google.protobuf.Empty) returns (.google.protobuf.Empty);
-   rpc Unary (MyRequest) returns (MyResponse);
 }
 ", schema, ignoreLineEndingDifferences: true);
         }
@@ -131,7 +125,7 @@ public interface INotAService
         [Theory]
         [InlineData(typeof(IMyService))]
         [InlineData(typeof(IMyInheritedService))]        
-        [InlineData(typeof(IMyAnotherLevelOfInheritedService))]        
+        [InlineData(typeof(IMyServiceInheritTwoLevelsOfHierarchy))]        
         public void CompareRouteTable(Type type)
         {
             // 1: use the existing binder logic to build the routes, using the server logic
@@ -184,14 +178,14 @@ public string[] Collect()
             }
         }
 
-        [Service]
-        public interface ISomeGenericService<in TGenericRequest, TGenericResult>
+        [ServiceInheritable]
+        public interface ISomeInheritableGenericService<in TGenericRequest, TGenericResult>
         {
             ValueTask<TGenericResult> GenericUnary(TGenericRequest request, CallContext callContext = default);
         }
 
         [Service]
-        public interface IMyInheritedService : IMyService, ISomeGenericService<MyRequest, MyResponse>, INotAService
+        public interface IMyInheritedService : ISomeInheritableGenericService<MyRequest, MyResponse>, INotAService
         {
             ValueTask<MyResponse> InheritedUnary(MyRequest request, CallContext callContext = default);
             ValueTask<MyResponse> InheritedClientStreaming(IAsyncEnumerable<MyRequest> request, CallContext callContext = default);
@@ -202,9 +196,20 @@ public interface IMyInheritedService : IMyService, ISomeGenericService<MyRequest
             void InheritedSyncEmpty();
         }
 
-                
+        [ServiceInheritable]
+        public interface ISecondLevelInheritable : ISomeInheritableGenericService<MyRequest, MyResponse>, INotAService
+        {
+            ValueTask<MyResponse> InheritedUnary(MyRequest request, CallContext callContext = default);
+            ValueTask<MyResponse> InheritedClientStreaming(IAsyncEnumerable<MyRequest> request, CallContext callContext = default);
+            IAsyncEnumerable<MyResponse> InheritedServerStreaming(MyRequest request, CallContext callContext = default);
+            IAsyncEnumerable<MyResponse> InheritedFullDuplex(IAsyncEnumerable<MyRequest> request, CallContext callContext = default);
+
+            ValueTask InheritedAsyncEmpty();
+            void InheritedSyncEmpty();
+        }
+
         [Service]
-        public interface IMyAnotherLevelOfInheritedService : IMyInheritedService
+        public interface IMyServiceInheritTwoLevelsOfHierarchy : ISecondLevelInheritable
         {
             ValueTask<MyResponse> AnotherMethod(MyRequest request, CallContext callContext = default);
         }