Now the json serialization should work with multiple methods in an interface

Signed-off-by: paule96 <[email protected]>

Author: paule96

src/Dapr.Actors/Communication/ActorMessageBodyJsonSerializationProvider.cs

@@ -104,7 +104,10 @@ public MemoryStreamMessageBodySerializer(
             {
                 var _methodRequestParameterTypes = new List<Type>(methodRequestParameterTypes);
                 var _wrappedRequestMessageTypes = new List<Type>(wrappedRequestMessageTypes);
-
+                if(_wrappedRequestMessageTypes.Count != 1){
+                    throw new NotSupportedException("JSON serialisation should always provide the actor method, that was called" +
+                        " to support (de)serialisation. This is a dapr sdk error, open an issue on github.");
+                }
                 this.serializerOptions = new(serializerOptions)
                 {
                     // Workaround since WrappedMessageBody creates an object

src/Dapr.Actors/Communication/ActorMessageSerializersManager.cs

@@ -15,11 +15,14 @@ namespace Dapr.Actors.Communication
 {
     using System;
     using System.Collections.Concurrent;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Linq;
     using Dapr.Actors.Builder;
 
     internal class ActorMessageSerializersManager
     {
-        private readonly ConcurrentDictionary<int, CacheEntry> cachedBodySerializers;
+        private readonly ConcurrentDictionary<(int, string), CacheEntry> cachedBodySerializers;
         private readonly IActorMessageHeaderSerializer headerSerializer;
         private readonly IActorMessageBodySerializationProvider serializationProvider;
 
@@ -38,7 +41,7 @@ public ActorMessageSerializersManager(
             }
 
             this.serializationProvider = serializationProvider;
-            this.cachedBodySerializers = new ConcurrentDictionary<int, CacheEntry>();
+            this.cachedBodySerializers = new ConcurrentDictionary<(int, string), CacheEntry>();
             this.headerSerializer = headerSerializer;
         }
 
@@ -52,19 +55,19 @@ public IActorMessageHeaderSerializer GetHeaderSerializer()
             return this.headerSerializer;
         }
 
-        public IActorRequestMessageBodySerializer GetRequestMessageBodySerializer(int interfaceId)
+        public IActorRequestMessageBodySerializer GetRequestMessageBodySerializer(int interfaceId, [AllowNull] string methodName = null)
         {
-            return this.cachedBodySerializers.GetOrAdd(interfaceId, this.CreateSerializers).RequestMessageBodySerializer;
+            return this.cachedBodySerializers.GetOrAdd((interfaceId, methodName), this.CreateSerializers).RequestMessageBodySerializer;
         }
 
-        public IActorResponseMessageBodySerializer GetResponseMessageBodySerializer(int interfaceId)
+        public IActorResponseMessageBodySerializer GetResponseMessageBodySerializer(int interfaceId, [AllowNull] string methodName = null)
         {
-            return this.cachedBodySerializers.GetOrAdd(interfaceId, this.CreateSerializers).ResponseMessageBodySerializer;
+            return this.cachedBodySerializers.GetOrAdd((interfaceId, methodName), this.CreateSerializers).ResponseMessageBodySerializer;
         }
 
-        internal CacheEntry CreateSerializers(int interfaceId)
+        internal CacheEntry CreateSerializers((int interfaceId, string methodName) data)
         {
-            var interfaceDetails = this.GetInterfaceDetails(interfaceId);
+            var interfaceDetails = this.GetInterfaceDetails(data.interfaceId);
 
             // get the service interface type from the code gen layer
             var serviceInterfaceType = interfaceDetails.ServiceInterfaceType;
@@ -74,10 +77,27 @@ internal CacheEntry CreateSerializers(int interfaceId)
 
             // get the known types from the codegen layer
             var responseBodyTypes = interfaceDetails.ResponseKnownTypes;
+            if (data.methodName is null)
+            {
+                // Path is mainly used for XML serialization
+                return new CacheEntry(
+                    this.serializationProvider.CreateRequestMessageBodySerializer(serviceInterfaceType, requestBodyTypes, interfaceDetails.RequestWrappedKnownTypes),
+                    this.serializationProvider.CreateResponseMessageBodySerializer(serviceInterfaceType, responseBodyTypes, interfaceDetails.ResponseWrappedKnownTypes));
+            }
+            else
+            {
+                // This path should be used for JSON serialization
+                var requestWrapperTypeAsList = new List<Type>(1){
+                    interfaceDetails.RequestWrappedKnownTypes.Single(r => r.Name == $"{data.methodName}ReqBody")
+                };
+                var responseWrapperTypeAsList = new List<Type>(1){
+                    interfaceDetails.RequestWrappedKnownTypes.Single(r => r.Name == $"{data.methodName}RespBody")
+                };
+                return new CacheEntry(
+                    this.serializationProvider.CreateRequestMessageBodySerializer(serviceInterfaceType, requestBodyTypes, requestWrapperTypeAsList),
+                    this.serializationProvider.CreateResponseMessageBodySerializer(serviceInterfaceType, responseBodyTypes, responseWrapperTypeAsList));
+            }
 
-            return new CacheEntry(
-               this.serializationProvider.CreateRequestMessageBodySerializer(serviceInterfaceType, requestBodyTypes, interfaceDetails.RequestWrappedKnownTypes),
-               this.serializationProvider.CreateResponseMessageBodySerializer(serviceInterfaceType, responseBodyTypes, interfaceDetails.ResponseWrappedKnownTypes));
         }
 
         internal InterfaceDetails GetInterfaceDetails(int interfaceId)

src/Dapr.Actors/DaprHttpInteractor.cs

@@ -116,7 +116,7 @@ public async Task<IActorResponseMessage> InvokeActorMethodWithRemotingAsync(Acto
             var serializedHeader = serializersManager.GetHeaderSerializer()
                 .SerializeRequestHeader(remotingRequestRequestMessage.GetHeader());
 
-            var msgBodySeriaizer = serializersManager.GetRequestMessageBodySerializer(interfaceId);
+            var msgBodySeriaizer = serializersManager.GetRequestMessageBodySerializer(interfaceId, methodName);
             var serializedMsgBody = msgBodySeriaizer.Serialize(remotingRequestRequestMessage.GetBody());
 
             // Send Request
@@ -170,7 +170,7 @@ HttpRequestMessage RequestFunc()
 
                 // Deserialize Actor Response Message Body
                 // Deserialize to ActorInvokeException when there is response header otherwise normal path
-                var responseBodySerializer = serializersManager.GetResponseMessageBodySerializer(interfaceId);
+                var responseBodySerializer = serializersManager.GetResponseMessageBodySerializer(interfaceId, methodName);
 
                 // actorResponseMessageHeader is not null, it means there is remote exception
                 if (actorResponseMessageHeader != null)

src/Dapr.Actors/Runtime/ActorManager.cs

@@ -106,8 +106,8 @@ internal async Task<Tuple<string, byte[]>> DispatchWithRemotingAsync(ActorId act
             var interfaceId = actorMessageHeader.InterfaceId;
 
             // Get the deserialized Body.
-            var msgBodySerializer = this.serializersManager.GetRequestMessageBodySerializer(actorMessageHeader.InterfaceId);
-
+            var msgBodySerializer = this.serializersManager.GetRequestMessageBodySerializer(actorMessageHeader.InterfaceId, actorMethodContext.MethodName);
+            
             IActorRequestMessageBody actorMessageBody;
             using (var stream = new MemoryStream())
             {
@@ -130,7 +130,7 @@ async Task<Tuple<string, byte[]>> RequestFunc(Actor actor, CancellationToken ct)
                     this.messageBodyFactory,
                     ct);
 
-                return this.CreateResponseMessage(responseMsgBody, interfaceId);
+                return this.CreateResponseMessage(responseMsgBody, interfaceId, actorMethodContext.MethodName);
             }
 
             return await this.DispatchInternalAsync(actorId, actorMethodContext, RequestFunc, cancellationToken);
@@ -387,12 +387,12 @@ private async Task<T> DispatchInternalAsync<T>(ActorId actorId, ActorMethodConte
             return retval;
         }
 
-        private Tuple<string, byte[]> CreateResponseMessage(IActorResponseMessageBody msgBody, int interfaceId)
+        private Tuple<string, byte[]> CreateResponseMessage(IActorResponseMessageBody msgBody, int interfaceId, string methodName)
         {
             var responseMsgBodyBytes = Array.Empty<byte>();
             if (msgBody != null)
             {
-                var responseSerializer = this.serializersManager.GetResponseMessageBodySerializer(interfaceId);
+                var responseSerializer = this.serializersManager.GetResponseMessageBodySerializer(interfaceId, methodName);
                 responseMsgBodyBytes = responseSerializer.Serialize(msgBody);
             }