Bug/476 multiple methods per interface with JSON serialization doesn´t work

.devcontainer/devcontainer.json

@@ -10,11 +10,15 @@
 		"ghcr.io/devcontainers/features/azure-cli:1": {
 			"version": "2.38"
 		},
-		"ghcr.io/devcontainers/features/docker-from-docker:1": {
-			"version": "20.10"
+		"ghcr.io/devcontainers/features/docker-in-docker": {
+			"version": "latest"
 		},
-		"ghcr.io/devcontainers/features/dotnet:1": {
-			"version": "6.0"
+		"ghcr.io/devcontainers/features/dotnet": {
+			"version": "8.0",
+			"additionalVersions": [
+				"6.0",
+				"7.0"
+			]
 		},
 		"ghcr.io/devcontainers/features/github-cli:1": {
 			"version": "2"
@@ -32,7 +36,8 @@
 		"ms-dotnettools.csharp",
 		"ms-dotnettools.vscode-dotnet-runtime",
 		"ms-azuretools.vscode-dapr",
-		"GitHub.copilot"
+		"GitHub.copilot",
+		"ms-dotnettools.csdevkit"
 	],
 	"forwardPorts": [
 		3000,
@@ -42,10 +47,9 @@
 		5000,
 		5007
 	],
-	"postCreateCommand": ".devcontainer/localinit.sh",
+	"postCreateCommand": "chmod +x .devcontainer/localinit.sh && .devcontainer/localinit.sh",
 	"remoteUser": "vscode",
 	"hostRequirements": {
 		"memory": "8gb"
 	}
-  }
-
+}

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 (or nothing), 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,29 @@ 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 = interfaceDetails.RequestWrappedKnownTypes.Where(r => r.Name == $"{data.methodName}ReqBody").ToList();
+                if(requestWrapperTypeAsList.Count > 1){
+                    throw new NotSupportedException($"More then one wrappertype was found for {data.methodName}");
+                }
+                var responseWrapperTypeAsList = interfaceDetails.ResponseWrappedKnownTypes.Where(r => r.Name == $"{data.methodName}RespBody").ToList();
+                    if(responseWrapperTypeAsList.Count > 1){
+                    throw new NotSupportedException($"More then one wrappertype was found for {data.methodName}");
+                }
+                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);
             }
 

test/Dapr.E2E.Test.Actors/ISerializationActor.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Text.Json;
 using System.Text.Json.Serialization;
@@ -10,6 +11,7 @@ namespace Dapr.E2E.Test.Actors
     public interface ISerializationActor : IActor, IPingActor
     {
         Task<SerializationPayload> SendAsync(string name, SerializationPayload payload, CancellationToken cancellationToken = default);
+        Task<DateTime> AnotherMethod(DateTime payload);
     }
 
     public record SerializationPayload(string Message)

test/Dapr.E2E.Test.App/Actors/SerializationActor.cs

@@ -1,4 +1,5 @@
 
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 using Dapr.Actors.Runtime;
@@ -22,5 +23,9 @@ public Task<SerializationPayload> SendAsync(string name,
         {
             return Task.FromResult(payload);
         }
+
+        public Task<DateTime> AnotherMethod(DateTime payload){
+            return Task.FromResult(payload);
+        }
     }
 }

test/Dapr.E2E.Test/Actors/E2ETests.CustomSerializerTests.cs

@@ -84,5 +84,32 @@ public async Task ActorCanSupportCustomSerializer()
                 Assert.Equal(JsonSerializer.Serialize(kvp.Value), JsonSerializer.Serialize(value));
             }
         }
+
+        /// <summary>
+        /// This was actually a problem that is why the test exists.
+        /// It just checks, if the interface of the actor has more than one method defined,
+        /// that if can call it and serialize the payload correctly.
+        /// </summary>
+        /// <remarks>
+        /// More than one methods means here, that in the exact interface must be two methods defined.
+        /// That excludes hirachies. 
+        /// So <see cref="IPingActor.Ping"/> wouldn't count here, because it's not directly defined in 
+        /// <see cref="ISerializationActor"/>. (it's defined in the base of it.)
+        /// That why <see cref="ISerializationActor.AnotherMethod(DateTime)"/> was created,
+        /// so there are now more then one method.
+        /// </remark>
+        [Fact]
+        public async Task ActorCanSupportCustomSerializerAndCallMoreThenOneDefinedMethod()
+        {
+            using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(60));
+            var proxy = this.ProxyFactory.CreateActorProxy<ISerializationActor>(ActorId.CreateRandom(), "SerializationActor");
+
+            await ActorRuntimeChecker.WaitForActorRuntimeAsync(this.AppId, this.Output, proxy, cts.Token);
+
+            var payload = DateTime.MinValue;
+            var result = await proxy.AnotherMethod(payload);
+
+            Assert.Equal(payload, result);
+        }
     }
 }