Support different TResult and TProgress with reflection-based callee (#353)

Péter Trombitás · Péter Trombitás · commit 17bee1bb3f20 · 2023-04-21T11:14:28.000+02:00
diff --git a/src/netstandard/WampSharp/WAMP2/V2/Rpc/Callee/Reflection/MethodInfoValidation.cs b/src/netstandard/WampSharp/WAMP2/V2/Rpc/Callee/Reflection/MethodInfoValidation.cs
@@ -104,9 +104,6 @@ public static void ValidateProgressiveMethod(MethodInfo method)
         {
             ValidateAsyncMethod(method);
 
-            Type returnType =
-                TaskExtensions.UnwrapReturnType(method.ReturnType);
-
             ParameterInfo[] parameters = method.GetParameters();
             ParameterInfo lastParameter = parameters.LastOrDefault();
             ParameterInfo progressParameter = lastParameter;
@@ -118,41 +115,9 @@ public static void ValidateProgressiveMethod(MethodInfo method)
                     parameters.Take(parameters.Length - 1).LastOrDefault();
             }
 
-            Type expectedParameterType =
-                typeof(IProgress<>).MakeGenericType(returnType);
-
-            if ((progressParameter == null) || (progressParameter.ParameterType != expectedParameterType))
-            {
-                ThrowHelper.ProgressiveParameterTypeMismatch(method, returnType);
-            }
-
-            ValidateTupleReturnTypeOfProgressiveMethod(method, progressParameter);
-        }
-
-        private static void ValidateTupleReturnTypeOfProgressiveMethod(MethodInfo method, ParameterInfo lastParameter)
-        {
-            TupleElementNamesAttribute methodAttribute =
-                method.ReturnParameter.GetCustomAttribute<TupleElementNamesAttribute>();
-
-            TupleElementNamesAttribute parameterAttribute =
-                lastParameter.GetCustomAttribute<TupleElementNamesAttribute>();
-
-            bool methodHasAttribute = methodAttribute != null;
-            bool parameterHasAttributte = parameterAttribute != null;
-
-            bool attributesMatch = methodHasAttribute == parameterHasAttributte;
-
-            if (methodHasAttribute && parameterHasAttributte)
-            {
-                IList<string> methodTransformNames = methodAttribute.TransformNames;
-                IList<string> parameterTransformNames = parameterAttribute.TransformNames;
-
-                attributesMatch = methodTransformNames.SequenceEqual(parameterTransformNames);
-            }
-
-            if (!attributesMatch)
+            if ((progressParameter == null) || (progressParameter.ParameterType.GetGenericTypeDefinition() != typeof(IProgress<>)))
             {
-                ThrowHelper.ProgressiveParameterTupleMismatch(method);
+                ThrowHelper.ProgressiveParameterTypeMismatch(method);
             }
         }
 
@@ -164,10 +129,10 @@ public static void AsyncOutRefMethod(MethodInfo method)
                     ($"Method {method.Name} of type {method.DeclaringType.FullName} is declared as a WAMP procedure, but it is both asynchronous and has out/ref parameters");
             }
 
-            public static void ProgressiveParameterTypeMismatch(MethodInfo method, Type returnType)
+            public static void ProgressiveParameterTypeMismatch(MethodInfo method)
             {
                 throw new ArgumentException
-                    ($"Method {method.Name} of type {method.DeclaringType.FullName} is declared as a progressive WAMP procedure, but its last (or second to last) parameter is not a IProgress of its return type. Expected: IProgress<{returnType.FullName}>");
+                    ($"Method {method.Name} of type {method.DeclaringType.FullName} is declared as a progressive WAMP procedure, but its last (or second to last) parameter is not an IProgress<TProgress>");
             }
 
             public static void ObservableMethodNotDeclaredProgressive(MethodInfo method)
@@ -176,12 +141,6 @@ public static void ObservableMethodNotDeclaredProgressive(MethodInfo method)
                     ($"Method {method.Name} of type {method.DeclaringType.FullName} is returning an IObservable and therefore is required to be declared as a progressive WAMP procedure, but it is not. Please use the [WampProgressiveResultProcedure] attribute.");
             }
 
-            public static void ProgressiveParameterTupleMismatch(MethodInfo method)
-            {
-                throw new ArgumentException
-                    ($"Method {method.Name} of type {method.DeclaringType.FullName} is declared as a progressive WAMP procedure that returns a tuple, but its last parameter tuple definition does not match its return type tuple definition.");
-            }
-
             public static void InvalidTupleReturnType(MethodInfo method)
             {
                 throw new ArgumentException
diff --git a/src/netstandard/WampSharp/WAMP2/V2/Rpc/Callee/Reflection/OperationExtractor.cs b/src/netstandard/WampSharp/WAMP2/V2/Rpc/Callee/Reflection/OperationExtractor.cs
@@ -1,6 +1,8 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Reflection;
+using System.Threading;
 using System.Threading.Tasks;
 using WampSharp.V2.Core.Contracts;
 using TaskExtensions = WampSharp.Core.Utilities.TaskExtensions;
@@ -62,14 +64,14 @@ protected IWampRpcOperation CreateRpcMethod(Func<object> instanceProvider, ICall
                 MethodInfoValidation.ValidateProgressiveObservableMethod(method);
                 return CreateProgressiveObservableOperation(instanceProvider, method, procedureUri);
             }
-            else if (!typeof (Task).IsAssignableFrom(method.ReturnType))
+            else if (!typeof(Task).IsAssignableFrom(method.ReturnType))
             {
                 MethodInfoValidation.ValidateSyncMethod(method);
                 return new SyncMethodInfoRpcOperation(instanceProvider, method, procedureUri);
             }
             else
             {
-                if (method.IsDefined(typeof (WampProgressiveResultProcedureAttribute)))
+                if (method.IsDefined(typeof(WampProgressiveResultProcedureAttribute)))
                 {
                     MethodInfoValidation.ValidateProgressiveMethod(method);
                     return CreateProgressiveOperation(instanceProvider, method, procedureUri);
@@ -89,13 +91,23 @@ private static IWampRpcOperation CreateProgressiveOperation(Func<object> instanc
 
             Type returnType =
                 TaskExtensions.UnwrapReturnType(method.ReturnType);
+            ParameterInfo[] parameters = method.GetParameters();
+            ParameterInfo lastParameter = parameters.LastOrDefault();
+            ParameterInfo progressParameter = lastParameter;
+
+            if ((lastParameter != null) &&
+                (lastParameter.ParameterType == typeof(CancellationToken)))
+            {
+                progressParameter =
+                    parameters.Take(parameters.Length - 1).LastOrDefault();
+            }
 
             Type operationType =
-                typeof (ProgressiveAsyncMethodInfoRpcOperation<>)
-                    .MakeGenericType(returnType);
+                typeof(ProgressiveAsyncMethodInfoRpcOperation<,>)
+                    .MakeGenericType(returnType, progressParameter.ParameterType.GetGenericArguments().First());
 
             IWampRpcOperation operation =
-                (IWampRpcOperation) Activator.CreateInstance(operationType,
+                (IWampRpcOperation)Activator.CreateInstance(operationType,
                     instanceProvider,
                     method,
                     procedureUri);
diff --git a/src/netstandard/WampSharp/WAMP2/V2/Rpc/Callee/Reflection/ProgressiveAsyncMethodInfoRpcOperation.cs b/src/netstandard/WampSharp/WAMP2/V2/Rpc/Callee/Reflection/ProgressiveAsyncMethodInfoRpcOperation.cs
@@ -3,17 +3,17 @@
 using System.Linq;
 using System.Reflection;
 using System.Threading;
-using WampSharp.Core.Utilities;
 using WampSharp.Core.Serialization;
+using WampSharp.Core.Utilities;
 using WampSharp.V2.Core.Contracts;
 
 namespace WampSharp.V2.Rpc
 {
-    public class ProgressiveAsyncMethodInfoRpcOperation<T> : AsyncMethodInfoRpcOperation
+    public class ProgressiveAsyncMethodInfoRpcOperation<TResult, TProgress> : AsyncMethodInfoRpcOperation
     {
         private readonly RpcParameter[] mRpcParameters;
 
-        public ProgressiveAsyncMethodInfoRpcOperation(Func<object> instanceProvider, MethodInfo method, string procedureName) : 
+        public ProgressiveAsyncMethodInfoRpcOperation(Func<object> instanceProvider, MethodInfo method, string procedureName) :
             base(instanceProvider, method, procedureName)
         {
             RpcParameter[] baseParameters = base.Parameters;
@@ -45,21 +45,21 @@ protected override object[] GetMethodParameters<TMessage>(IWampRawRpcOperationRo
 
         public override RpcParameter[] Parameters => mRpcParameters;
 
-        private class CallerProgress : IProgress<T>
+        private class CallerProgress : IProgress<TProgress>
         {
             private readonly IWampRawRpcOperationRouterCallback mCaller;
-            private readonly ProgressiveAsyncMethodInfoRpcOperation<T> mParent;
+            private readonly ProgressiveAsyncMethodInfoRpcOperation<TResult, TProgress> mParent;
 
             public CallerProgress(IWampRawRpcOperationRouterCallback caller,
-                                  ProgressiveAsyncMethodInfoRpcOperation<T> parent)
+                                  ProgressiveAsyncMethodInfoRpcOperation<TResult, TProgress> parent)
             {
                 mCaller = caller;
                 mParent = parent;
             }
 
-            public void Report(T value)
+            public void Report(TProgress value)
             {
-                mParent.CallResult(mCaller, value, new YieldOptions() {Progress = true});
+                mParent.CallResult(mCaller, value, new YieldOptions() { Progress = true });
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -3,17 +3,17 @@`
`3`	`3`	`using System.Linq;`
`4`	`4`	`using System.Reflection;`
`5`	`5`	`using System.Threading;`
`6`		`-using WampSharp.Core.Utilities;`
`7`	`6`	`using WampSharp.Core.Serialization;`
	`7`	`+using WampSharp.Core.Utilities;`
`8`	`8`	`using WampSharp.V2.Core.Contracts;`
`9`	`9`
`10`	`10`	`namespace WampSharp.V2.Rpc`
`11`	`11`	`{`
`12`		`- public class ProgressiveAsyncMethodInfoRpcOperation<T> : AsyncMethodInfoRpcOperation`
	`12`	`+ public class ProgressiveAsyncMethodInfoRpcOperation<TResult, TProgress> : AsyncMethodInfoRpcOperation`
`13`	`13`	`{`
`14`	`14`	`private readonly RpcParameter[] mRpcParameters;`
`15`	`15`
`16`		`- public ProgressiveAsyncMethodInfoRpcOperation(Func<object> instanceProvider, MethodInfo method, string procedureName) :`
	`16`	`+ public ProgressiveAsyncMethodInfoRpcOperation(Func<object> instanceProvider, MethodInfo method, string procedureName) :`
`17`	`17`	`base(instanceProvider, method, procedureName)`
`18`	`18`	`{`
`19`	`19`	`RpcParameter[] baseParameters = base.Parameters;`
`@@ -45,21 +45,21 @@ protected override object[] GetMethodParameters<TMessage>(IWampRawRpcOperationRo`
`45`	`45`
`46`	`46`	`public override RpcParameter[] Parameters => mRpcParameters;`
`47`	`47`
`48`		`- private class CallerProgress : IProgress<T>`
	`48`	`+ private class CallerProgress : IProgress<TProgress>`
`49`	`49`	`{`
`50`	`50`	`private readonly IWampRawRpcOperationRouterCallback mCaller;`
`51`		`- private readonly ProgressiveAsyncMethodInfoRpcOperation<T> mParent;`
	`51`	`+ private readonly ProgressiveAsyncMethodInfoRpcOperation<TResult, TProgress> mParent;`
`52`	`52`
`53`	`53`	`public CallerProgress(IWampRawRpcOperationRouterCallback caller,`
`54`		`- ProgressiveAsyncMethodInfoRpcOperation<T> parent)`
	`54`	`+ ProgressiveAsyncMethodInfoRpcOperation<TResult, TProgress> parent)`
`55`	`55`	`{`
`56`	`56`	`mCaller = caller;`
`57`	`57`	`mParent = parent;`
`58`	`58`	`}`
`59`	`59`
`60`		`- public void Report(T value)`
	`60`	`+ public void Report(TProgress value)`
`61`	`61`	`{`
`62`		`- mParent.CallResult(mCaller, value, new YieldOptions() {Progress = true});`
	`62`	`+ mParent.CallResult(mCaller, value, new YieldOptions() { Progress = true });`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`	`}`