Update signatures to leverage SerializedArgs

TanayParikh · TanayParikh · commit b0b5a6bab7c1 · 2021-05-23T19:24:26.000-07:00
diff --git a/src/Components/Server/src/Circuits/CircuitHost.cs b/src/Components/Server/src/Circuits/CircuitHost.cs
@@ -12,6 +12,7 @@
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using Microsoft.JSInterop;
 using Microsoft.JSInterop.Infrastructure;
 
 namespace Microsoft.AspNetCore.Components.Server.Circuits
@@ -336,7 +337,7 @@ public async Task OnRenderCompletedAsync(long renderId, string errorMessageOrNul
 
         // BeginInvokeDotNetFromJS is used in a fire-and-forget context, so it's responsible for its own
         // error handling.
-        public async Task BeginInvokeDotNetFromJS(string callId, string assemblyName, string methodIdentifier, long dotNetObjectId, string argsJson, byte[][]? byteArrays)
+        public async Task BeginInvokeDotNetFromJS(string callId, string assemblyName, string methodIdentifier, long dotNetObjectId, SerializedArgs serializedArgs)
         {
             AssertInitialized();
             AssertNotDisposed();
@@ -347,7 +348,7 @@ await Renderer.Dispatcher.InvokeAsync(() =>
                 {
                     Log.BeginInvokeDotNet(_logger, callId, assemblyName, methodIdentifier, dotNetObjectId);
                     var invocationInfo = new DotNetInvocationInfo(assemblyName, methodIdentifier, dotNetObjectId, callId);
-                    DotNetDispatcher.BeginInvokeDotNet(JSRuntime, invocationInfo, argsJson, byteArrays);
+                    DotNetDispatcher.BeginInvokeDotNet(JSRuntime, invocationInfo, serializedArgs);
                 });
             }
             catch (Exception ex)
@@ -362,7 +363,7 @@ await Renderer.Dispatcher.InvokeAsync(() =>
 
         // EndInvokeJSFromDotNet is used in a fire-and-forget context, so it's responsible for its own
         // error handling.
-        public async Task EndInvokeJSFromDotNet(long callId, bool succeeded, string resultOrError, byte[][]? byteArrays)
+        public async Task EndInvokeJSFromDotNet(long callId, bool succeeded, SerializedArgs serializedArgs)
         {
             AssertInitialized();
             AssertNotDisposed();
@@ -374,14 +375,14 @@ await Renderer.Dispatcher.InvokeAsync(() =>
                     if (!succeeded)
                     {
                         // We can log the arguments here because it is simply the JS error with the call stack.
-                        Log.EndInvokeJSFailed(_logger, callId, resultOrError);
+                        Log.EndInvokeJSFailed(_logger, callId, serializedArgs.ArgsJson);
                     }
                     else
                     {
                         Log.EndInvokeJSSucceeded(_logger, callId);
                     }
 
-                    DotNetDispatcher.EndInvokeJS(JSRuntime, resultOrError, byteArrays);
+                    DotNetDispatcher.EndInvokeJS(JSRuntime, serializedArgs);
                 });
             }
             catch (Exception ex)
diff --git a/src/Components/Server/src/ComponentHub.cs b/src/Components/Server/src/ComponentHub.cs
@@ -9,6 +9,7 @@
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.Extensions.Logging;
+using Microsoft.JSInterop;
 
 namespace Microsoft.AspNetCore.Components.Server
 {
@@ -195,7 +196,8 @@ public async ValueTask BeginInvokeDotNetFromJS(string callId, string assemblyNam
                 return;
             }
 
-            _ = circuitHost.BeginInvokeDotNetFromJS(callId, assemblyName, methodIdentifier, dotNetObjectId, argsJson, byteArrays);
+            var serializedArgs = new SerializedArgs(argsJson, byteArrays);
+            _ = circuitHost.BeginInvokeDotNetFromJS(callId, assemblyName, methodIdentifier, dotNetObjectId, serializedArgs);
         }
 
         public async ValueTask EndInvokeJSFromDotNet(long callId, bool succeeded, string resultOrError, byte[][] byteArrays)
@@ -206,7 +208,8 @@ public async ValueTask EndInvokeJSFromDotNet(long callId, bool succeeded, string
                 return;
             }
 
-            _ = circuitHost.EndInvokeJSFromDotNet(callId, succeeded, resultOrError, byteArrays);
+            var serializedArgs = new SerializedArgs(resultOrError, byteArrays);
+            _ = circuitHost.EndInvokeJSFromDotNet(callId, succeeded, serializedArgs);
         }
 
         public async ValueTask DispatchBrowserEvent(string eventDescriptor, string eventArgs)
diff --git a/src/JSInterop/Microsoft.JSInterop/src/Infrastructure/DotNetDispatcher.cs b/src/JSInterop/Microsoft.JSInterop/src/Infrastructure/DotNetDispatcher.cs
@@ -35,10 +35,9 @@ public static class DotNetDispatcher
         /// </summary>
         /// <param name="jsRuntime">The <see cref="JSRuntime"/>.</param>
         /// <param name="invocationInfo">The <see cref="DotNetInvocationInfo"/>.</param>
-        /// <param name="argsJson">A JSON representation of the parameters.</param>
-        /// <param name="byteArrays">Byte array data extracted from the arguments for direct transfer.</param>
+        /// <param name="serializedArgs">The serialized args containing the JSON representation along with the extracted byte arrays.</param>
         /// <returns>A record containing the JSON representation of the return value, or null, along with the extracted byte arrays, or null.</returns>
-        public static SerializedArgs Invoke(JSRuntime jsRuntime, in DotNetInvocationInfo invocationInfo, string argsJson, byte[][]? byteArrays)
+        public static SerializedArgs Invoke(JSRuntime jsRuntime, in DotNetInvocationInfo invocationInfo, SerializedArgs serializedArgs)
         {
             // This method doesn't need [JSInvokable] because the platform is responsible for having
             // some way to dispatch calls here. The logic inside here is the thing that checks whether
@@ -51,7 +50,7 @@ public static SerializedArgs Invoke(JSRuntime jsRuntime, in DotNetInvocationInfo
                 targetInstance = jsRuntime.GetObjectReference(invocationInfo.DotNetObjectId);
             }
 
-            var syncResult = InvokeSynchronously(jsRuntime, invocationInfo, targetInstance, argsJson, byteArrays);
+            var syncResult = InvokeSynchronously(jsRuntime, invocationInfo, targetInstance, serializedArgs);
             if (syncResult == null)
             {
                 return new SerializedArgs(null, null);
@@ -65,9 +64,8 @@ public static SerializedArgs Invoke(JSRuntime jsRuntime, in DotNetInvocationInfo
         /// </summary>
         /// <param name="jsRuntime">The <see cref="JSRuntime"/>.</param>
         /// <param name="invocationInfo">The <see cref="DotNetInvocationInfo"/>.</param>
-        /// <param name="argsJson">A JSON representation of the parameters.</param>
-        /// <param name="byteArrays">Byte array data extracted from the arguments for direct transfer.</param>
-        public static void BeginInvokeDotNet(JSRuntime jsRuntime, DotNetInvocationInfo invocationInfo, string argsJson, byte[][]? byteArrays)
+        /// <param name="serializedArgs">The serialized args containing the JSON representation along with the extracted byte arrays.</param>
+        public static void BeginInvokeDotNet(JSRuntime jsRuntime, DotNetInvocationInfo invocationInfo, SerializedArgs serializedArgs)
         {
             // This method doesn't need [JSInvokable] because the platform is responsible for having
             // some way to dispatch calls here. The logic inside here is the thing that checks whether
@@ -89,7 +87,7 @@ public static void BeginInvokeDotNet(JSRuntime jsRuntime, DotNetInvocationInfo i
                     targetInstance = jsRuntime.GetObjectReference(invocationInfo.DotNetObjectId);
                 }
 
-                syncResult = InvokeSynchronously(jsRuntime, invocationInfo, targetInstance, argsJson, byteArrays);
+                syncResult = InvokeSynchronously(jsRuntime, invocationInfo, targetInstance, serializedArgs);
             }
             catch (Exception ex)
             {
@@ -114,9 +112,8 @@ public static void BeginInvokeDotNet(JSRuntime jsRuntime, DotNetInvocationInfo i
             }
             else
             {
-
-                var serializedArgs = SerializeArgs(jsRuntime, syncResult);
-                var dispatchResult = new DotNetInvocationResult(serializedArgs);
+                var serializedReturnArgs = SerializeArgs(jsRuntime, syncResult);
+                var dispatchResult = new DotNetInvocationResult(serializedReturnArgs);
                 jsRuntime.EndInvokeDotNet(invocationInfo, dispatchResult);
             }
         }
@@ -135,7 +132,7 @@ private static void EndInvokeDotNetAfterTask(Task task, JSRuntime jsRuntime, in
             jsRuntime.EndInvokeDotNet(invocationInfo, new DotNetInvocationResult(serializedArgs));
         }
 
-        private static object? InvokeSynchronously(JSRuntime jsRuntime, in DotNetInvocationInfo callInfo, IDotNetObjectReference? objectReference, string argsJson, byte[][]? byteArrays)
+        private static object? InvokeSynchronously(JSRuntime jsRuntime, in DotNetInvocationInfo callInfo, IDotNetObjectReference? objectReference, SerializedArgs serializedArgs)
         {
             var assemblyName = callInfo.AssemblyName;
             var methodIdentifier = callInfo.MethodIdentifier;
@@ -165,7 +162,7 @@ private static void EndInvokeDotNetAfterTask(Task task, JSRuntime jsRuntime, in
                 (methodInfo, parameterTypes) = GetCachedMethodInfo(objectReference, methodIdentifier);
             }
 
-            var suppliedArgs = ParseArguments(jsRuntime, methodIdentifier, argsJson, byteArrays, parameterTypes);
+            var suppliedArgs = ParseArguments(jsRuntime, methodIdentifier, serializedArgs, parameterTypes);
 
             try
             {
@@ -184,14 +181,14 @@ private static void EndInvokeDotNetAfterTask(Task task, JSRuntime jsRuntime, in
             }
         }
 
-        internal static object?[] ParseArguments(JSRuntime jsRuntime, string methodIdentifier, string arguments, byte[][]? byteArrays, Type[] parameterTypes)
+        internal static object?[] ParseArguments(JSRuntime jsRuntime, string methodIdentifier, SerializedArgs serializedArgs, Type[] parameterTypes)
         {
             if (parameterTypes.Length == 0)
             {
                 return Array.Empty<object>();
             }
 
-            var utf8JsonBytes = Encoding.UTF8.GetBytes(arguments);
+            var utf8JsonBytes = Encoding.UTF8.GetBytes(serializedArgs.ArgsJson ?? string.Empty);
             var reader = new Utf8JsonReader(utf8JsonBytes);
             if (!reader.Read() || reader.TokenType != JsonTokenType.StartArray)
             {
@@ -200,7 +197,7 @@ private static void EndInvokeDotNetAfterTask(Task task, JSRuntime jsRuntime, in
 
             var suppliedArgs = new object?[parameterTypes.Length];
 
-            jsRuntime.ByteArrayJsonConverter.ByteArraysToDeserialize = byteArrays;
+            jsRuntime.ByteArrayJsonConverter.ByteArraysToDeserialize = serializedArgs.ByteArrays;
 
             var index = 0;
             while (index < parameterTypes.Length && reader.Read() && reader.TokenType != JsonTokenType.EndArray)
@@ -263,15 +260,14 @@ static bool IsIncorrectDotNetObjectRefUse(Type parameterType, Utf8JsonReader jso
         /// passed in as parameters.
         /// </remarks>
         /// <param name="jsRuntime">The <see cref="JSRuntime"/>.</param>
-        /// <param name="arguments">The serialized arguments for the callback completion.</param>
-        /// <param name="byteArrays">Byte array data extracted from the arguments for direct transfer.</param>
+        /// <param name="serializedArgs">The serialized args containing the JSON representation along with the extracted byte arrays.</param>
         /// <exception cref="Exception">
         /// This method can throw any exception either from the argument received or as a result
         /// of executing any callback synchronously upon completion.
         /// </exception>
-        public static void EndInvokeJS(JSRuntime jsRuntime, string arguments, byte[][]? byteArrays)
+        public static void EndInvokeJS(JSRuntime jsRuntime, SerializedArgs serializedArgs)
         {
-            var utf8JsonBytes = Encoding.UTF8.GetBytes(arguments);
+            var utf8JsonBytes = Encoding.UTF8.GetBytes(serializedArgs.ArgsJson ?? string.Empty);
 
             // The payload that we're trying to parse is of the format
             // [ taskId: long, success: boolean, value: string? | object ]
@@ -292,7 +288,7 @@ public static void EndInvokeJS(JSRuntime jsRuntime, string arguments, byte[][]?
             var success = reader.GetBoolean();
 
             reader.Read();
-            jsRuntime.EndInvokeJS(taskId, success, ref reader, byteArrays);
+            jsRuntime.EndInvokeJS(taskId, success, ref reader, serializedArgs.ByteArrays);
 
             if (!reader.Read() || reader.TokenType != JsonTokenType.EndArray)
             {
diff --git a/src/JSInterop/Microsoft.JSInterop/src/PublicAPI.Unshipped.txt b/src/JSInterop/Microsoft.JSInterop/src/PublicAPI.Unshipped.txt
@@ -14,9 +14,9 @@ static Microsoft.JSInterop.Implementation.JSObjectReferenceJsonWorker.WriteJSObj
 *REMOVED*Microsoft.JSInterop.Infrastructure.DotNetInvocationResult.DotNetInvocationResult(object? result) -> void
 *REMOVED*Microsoft.JSInterop.Infrastructure.DotNetInvocationResult.Result.get -> object?
 *REMOVED*static Microsoft.JSInterop.JSInProcessObjectReferenceExtensions.InvokeVoid(this Microsoft.JSInterop.IJSInProcessObjectReference! jsObjectReference, string! identifier, params object?[]! args) -> void
-static Microsoft.JSInterop.Infrastructure.DotNetDispatcher.BeginInvokeDotNet(Microsoft.JSInterop.JSRuntime! jsRuntime, Microsoft.JSInterop.Infrastructure.DotNetInvocationInfo invocationInfo, string! argsJson, byte[]![]? byteArrays) -> void
-static Microsoft.JSInterop.Infrastructure.DotNetDispatcher.EndInvokeJS(Microsoft.JSInterop.JSRuntime! jsRuntime, string! arguments, byte[]![]? byteArrays) -> void
-static Microsoft.JSInterop.Infrastructure.DotNetDispatcher.Invoke(Microsoft.JSInterop.JSRuntime! jsRuntime, in Microsoft.JSInterop.Infrastructure.DotNetInvocationInfo invocationInfo, string! argsJson, byte[]![]? byteArrays) -> Microsoft.JSInterop.SerializedArgs
+static Microsoft.JSInterop.Infrastructure.DotNetDispatcher.BeginInvokeDotNet(Microsoft.JSInterop.JSRuntime! jsRuntime, Microsoft.JSInterop.Infrastructure.DotNetInvocationInfo invocationInfo, Microsoft.JSInterop.SerializedArgs serializedArgs) -> void
+static Microsoft.JSInterop.Infrastructure.DotNetDispatcher.EndInvokeJS(Microsoft.JSInterop.JSRuntime! jsRuntime, Microsoft.JSInterop.SerializedArgs serializedArgs) -> void
+static Microsoft.JSInterop.Infrastructure.DotNetDispatcher.Invoke(Microsoft.JSInterop.JSRuntime! jsRuntime, in Microsoft.JSInterop.Infrastructure.DotNetInvocationInfo invocationInfo, Microsoft.JSInterop.SerializedArgs serializedArgs) -> Microsoft.JSInterop.SerializedArgs
 static Microsoft.JSInterop.JSInProcessObjectReferenceExtensions.InvokeVoid(this Microsoft.JSInterop.IJSInProcessObjectReference! jsObjectReference, string! identifier, params object?[]? args) -> void
 *REMOVED*static Microsoft.JSInterop.JSInProcessRuntimeExtensions.InvokeVoid(this Microsoft.JSInterop.IJSInProcessRuntime! jsRuntime, string! identifier, params object?[]! args) -> void
 static Microsoft.JSInterop.JSInProcessRuntimeExtensions.InvokeVoid(this Microsoft.JSInterop.IJSInProcessRuntime! jsRuntime, string! identifier, params object?[]? args) -> void

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@`
`12`	`12`	`using Microsoft.AspNetCore.SignalR;`
`13`	`13`	`using Microsoft.Extensions.DependencyInjection;`
`14`	`14`	`using Microsoft.Extensions.Logging;`
	`15`	`+using Microsoft.JSInterop;`
`15`	`16`	`using Microsoft.JSInterop.Infrastructure;`
`16`	`17`
`17`	`18`	`namespace Microsoft.AspNetCore.Components.Server.Circuits`
`@@ -336,7 +337,7 @@ public async Task OnRenderCompletedAsync(long renderId, string errorMessageOrNul`
`336`	`337`
`337`	`338`	`// BeginInvokeDotNetFromJS is used in a fire-and-forget context, so it's responsible for its own`
`338`	`339`	`// error handling.`
`339`		`- public async Task BeginInvokeDotNetFromJS(string callId, string assemblyName, string methodIdentifier, long dotNetObjectId, string argsJson, byte[][]? byteArrays)`
	`340`	`+ public async Task BeginInvokeDotNetFromJS(string callId, string assemblyName, string methodIdentifier, long dotNetObjectId, SerializedArgs serializedArgs)`
`340`	`341`	`{`
`341`	`342`	`AssertInitialized();`
`342`	`343`	`AssertNotDisposed();`
`@@ -347,7 +348,7 @@ await Renderer.Dispatcher.InvokeAsync(() =>`
`347`	`348`	`{`
`348`	`349`	`Log.BeginInvokeDotNet(_logger, callId, assemblyName, methodIdentifier, dotNetObjectId);`
`349`	`350`	`var invocationInfo = new DotNetInvocationInfo(assemblyName, methodIdentifier, dotNetObjectId, callId);`
`350`		`- DotNetDispatcher.BeginInvokeDotNet(JSRuntime, invocationInfo, argsJson, byteArrays);`
	`351`	`+ DotNetDispatcher.BeginInvokeDotNet(JSRuntime, invocationInfo, serializedArgs);`
`351`	`352`	`});`
`352`	`353`	`}`
`353`	`354`	`catch (Exception ex)`
`@@ -362,7 +363,7 @@ await Renderer.Dispatcher.InvokeAsync(() =>`
`362`	`363`
`363`	`364`	`// EndInvokeJSFromDotNet is used in a fire-and-forget context, so it's responsible for its own`
`364`	`365`	`// error handling.`
`365`		`- public async Task EndInvokeJSFromDotNet(long callId, bool succeeded, string resultOrError, byte[][]? byteArrays)`
	`366`	`+ public async Task EndInvokeJSFromDotNet(long callId, bool succeeded, SerializedArgs serializedArgs)`
`366`	`367`	`{`
`367`	`368`	`AssertInitialized();`
`368`	`369`	`AssertNotDisposed();`
`@@ -374,14 +375,14 @@ await Renderer.Dispatcher.InvokeAsync(() =>`
`374`	`375`	`if (!succeeded)`
`375`	`376`	`{`
`376`	`377`	`// We can log the arguments here because it is simply the JS error with the call stack.`
`377`		`- Log.EndInvokeJSFailed(_logger, callId, resultOrError);`
	`378`	`+ Log.EndInvokeJSFailed(_logger, callId, serializedArgs.ArgsJson);`
`378`	`379`	`}`
`379`	`380`	`else`
`380`	`381`	`{`
`381`	`382`	`Log.EndInvokeJSSucceeded(_logger, callId);`
`382`	`383`	`}`
`383`	`384`
`384`		`- DotNetDispatcher.EndInvokeJS(JSRuntime, resultOrError, byteArrays);`
	`385`	`+ DotNetDispatcher.EndInvokeJS(JSRuntime, serializedArgs);`
`385`	`386`	`});`
`386`	`387`	`}`
`387`	`388`	`catch (Exception ex)`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`using Microsoft.AspNetCore.Http;`
`10`	`10`	`using Microsoft.AspNetCore.SignalR;`
`11`	`11`	`using Microsoft.Extensions.Logging;`
	`12`	`+using Microsoft.JSInterop;`
`12`	`13`
`13`	`14`	`namespace Microsoft.AspNetCore.Components.Server`
`14`	`15`	`{`
`@@ -195,7 +196,8 @@ public async ValueTask BeginInvokeDotNetFromJS(string callId, string assemblyNam`
`195`	`196`	`return;`
`196`	`197`	`}`
`197`	`198`
`198`		`- _ = circuitHost.BeginInvokeDotNetFromJS(callId, assemblyName, methodIdentifier, dotNetObjectId, argsJson, byteArrays);`
	`199`	`+ var serializedArgs = new SerializedArgs(argsJson, byteArrays);`
	`200`	`+ _ = circuitHost.BeginInvokeDotNetFromJS(callId, assemblyName, methodIdentifier, dotNetObjectId, serializedArgs);`
`199`	`201`	`}`
`200`	`202`
`201`	`203`	`public async ValueTask EndInvokeJSFromDotNet(long callId, bool succeeded, string resultOrError, byte[][] byteArrays)`
`@@ -206,7 +208,8 @@ public async ValueTask EndInvokeJSFromDotNet(long callId, bool succeeded, string`
`206`	`208`	`return;`
`207`	`209`	`}`
`208`	`210`
`209`		`- _ = circuitHost.EndInvokeJSFromDotNet(callId, succeeded, resultOrError, byteArrays);`
	`211`	`+ var serializedArgs = new SerializedArgs(resultOrError, byteArrays);`
	`212`	`+ _ = circuitHost.EndInvokeJSFromDotNet(callId, succeeded, serializedArgs);`
`210`	`213`	`}`
`211`	`214`
`212`	`215`	`public async ValueTask DispatchBrowserEvent(string eventDescriptor, string eventArgs)`
Original file line number	Diff line number	Diff line change
`@@ -35,10 +35,9 @@ public static class DotNetDispatcher`
`35`	`35`	`/// </summary>`
`36`	`36`	`/// <param name="jsRuntime">The <see cref="JSRuntime"/>.</param>`
`37`	`37`	`/// <param name="invocationInfo">The <see cref="DotNetInvocationInfo"/>.</param>`
`38`		`- /// <param name="argsJson">A JSON representation of the parameters.</param>`
`39`		`- /// <param name="byteArrays">Byte array data extracted from the arguments for direct transfer.</param>`
	`38`	`+ /// <param name="serializedArgs">The serialized args containing the JSON representation along with the extracted byte arrays.</param>`
`40`	`39`	`/// <returns>A record containing the JSON representation of the return value, or null, along with the extracted byte arrays, or null.</returns>`
`41`		`- public static SerializedArgs Invoke(JSRuntime jsRuntime, in DotNetInvocationInfo invocationInfo, string argsJson, byte[][]? byteArrays)`
	`40`	`+ public static SerializedArgs Invoke(JSRuntime jsRuntime, in DotNetInvocationInfo invocationInfo, SerializedArgs serializedArgs)`
`42`	`41`	`{`
`43`	`42`	`// This method doesn't need [JSInvokable] because the platform is responsible for having`
`44`	`43`	`// some way to dispatch calls here. The logic inside here is the thing that checks whether`
`@@ -51,7 +50,7 @@ public static SerializedArgs Invoke(JSRuntime jsRuntime, in DotNetInvocationInfo`
`51`	`50`	`targetInstance = jsRuntime.GetObjectReference(invocationInfo.DotNetObjectId);`
`52`	`51`	`}`
`53`	`52`
`54`		`- var syncResult = InvokeSynchronously(jsRuntime, invocationInfo, targetInstance, argsJson, byteArrays);`
	`53`	`+ var syncResult = InvokeSynchronously(jsRuntime, invocationInfo, targetInstance, serializedArgs);`
`55`	`54`	`if (syncResult == null)`
`56`	`55`	`{`
`57`	`56`	`return new SerializedArgs(null, null);`
`@@ -65,9 +64,8 @@ public static SerializedArgs Invoke(JSRuntime jsRuntime, in DotNetInvocationInfo`
`65`	`64`	`/// </summary>`
`66`	`65`	`/// <param name="jsRuntime">The <see cref="JSRuntime"/>.</param>`
`67`	`66`	`/// <param name="invocationInfo">The <see cref="DotNetInvocationInfo"/>.</param>`
`68`		`- /// <param name="argsJson">A JSON representation of the parameters.</param>`
`69`		`- /// <param name="byteArrays">Byte array data extracted from the arguments for direct transfer.</param>`
`70`		`- public static void BeginInvokeDotNet(JSRuntime jsRuntime, DotNetInvocationInfo invocationInfo, string argsJson, byte[][]? byteArrays)`
	`67`	`+ /// <param name="serializedArgs">The serialized args containing the JSON representation along with the extracted byte arrays.</param>`
	`68`	`+ public static void BeginInvokeDotNet(JSRuntime jsRuntime, DotNetInvocationInfo invocationInfo, SerializedArgs serializedArgs)`
`71`	`69`	`{`
`72`	`70`	`// This method doesn't need [JSInvokable] because the platform is responsible for having`
`73`	`71`	`// some way to dispatch calls here. The logic inside here is the thing that checks whether`
`@@ -89,7 +87,7 @@ public static void BeginInvokeDotNet(JSRuntime jsRuntime, DotNetInvocationInfo i`
`89`	`87`	`targetInstance = jsRuntime.GetObjectReference(invocationInfo.DotNetObjectId);`
`90`	`88`	`}`
`91`	`89`
`92`		`- syncResult = InvokeSynchronously(jsRuntime, invocationInfo, targetInstance, argsJson, byteArrays);`
	`90`	`+ syncResult = InvokeSynchronously(jsRuntime, invocationInfo, targetInstance, serializedArgs);`
`93`	`91`	`}`
`94`	`92`	`catch (Exception ex)`
`95`	`93`	`{`
`@@ -114,9 +112,8 @@ public static void BeginInvokeDotNet(JSRuntime jsRuntime, DotNetInvocationInfo i`
`114`	`112`	`}`
`115`	`113`	`else`
`116`	`114`	`{`
`117`		`-`
`118`		`- var serializedArgs = SerializeArgs(jsRuntime, syncResult);`
`119`		`- var dispatchResult = new DotNetInvocationResult(serializedArgs);`
	`115`	`+ var serializedReturnArgs = SerializeArgs(jsRuntime, syncResult);`
	`116`	`+ var dispatchResult = new DotNetInvocationResult(serializedReturnArgs);`
`120`	`117`	`jsRuntime.EndInvokeDotNet(invocationInfo, dispatchResult);`
`121`	`118`	`}`
`122`	`119`	`}`
`@@ -135,7 +132,7 @@ private static void EndInvokeDotNetAfterTask(Task task, JSRuntime jsRuntime, in`
`135`	`132`	`jsRuntime.EndInvokeDotNet(invocationInfo, new DotNetInvocationResult(serializedArgs));`
`136`	`133`	`}`
`137`	`134`
`138`		`- private static object? InvokeSynchronously(JSRuntime jsRuntime, in DotNetInvocationInfo callInfo, IDotNetObjectReference? objectReference, string argsJson, byte[][]? byteArrays)`
	`135`	`+ private static object? InvokeSynchronously(JSRuntime jsRuntime, in DotNetInvocationInfo callInfo, IDotNetObjectReference? objectReference, SerializedArgs serializedArgs)`
`139`	`136`	`{`
`140`	`137`	`var assemblyName = callInfo.AssemblyName;`
`141`	`138`	`var methodIdentifier = callInfo.MethodIdentifier;`
`@@ -165,7 +162,7 @@ private static void EndInvokeDotNetAfterTask(Task task, JSRuntime jsRuntime, in`
`165`	`162`	`(methodInfo, parameterTypes) = GetCachedMethodInfo(objectReference, methodIdentifier);`
`166`	`163`	`}`
`167`	`164`
`168`		`- var suppliedArgs = ParseArguments(jsRuntime, methodIdentifier, argsJson, byteArrays, parameterTypes);`
	`165`	`+ var suppliedArgs = ParseArguments(jsRuntime, methodIdentifier, serializedArgs, parameterTypes);`
`169`	`166`
`170`	`167`	`try`
`171`	`168`	`{`
`@@ -184,14 +181,14 @@ private static void EndInvokeDotNetAfterTask(Task task, JSRuntime jsRuntime, in`
`184`	`181`	`}`
`185`	`182`	`}`
`186`	`183`
`187`		`- internal static object?[] ParseArguments(JSRuntime jsRuntime, string methodIdentifier, string arguments, byte[][]? byteArrays, Type[] parameterTypes)`
	`184`	`+ internal static object?[] ParseArguments(JSRuntime jsRuntime, string methodIdentifier, SerializedArgs serializedArgs, Type[] parameterTypes)`
`188`	`185`	`{`
`189`	`186`	`if (parameterTypes.Length == 0)`
`190`	`187`	`{`
`191`	`188`	`return Array.Empty<object>();`
`192`	`189`	`}`
`193`	`190`
`194`		`- var utf8JsonBytes = Encoding.UTF8.GetBytes(arguments);`
	`191`	`+ var utf8JsonBytes = Encoding.UTF8.GetBytes(serializedArgs.ArgsJson ?? string.Empty);`
`195`	`192`	`var reader = new Utf8JsonReader(utf8JsonBytes);`
`196`	`193`	`if (!reader.Read() \|\| reader.TokenType != JsonTokenType.StartArray)`
`197`	`194`	`{`
`@@ -200,7 +197,7 @@ private static void EndInvokeDotNetAfterTask(Task task, JSRuntime jsRuntime, in`
`200`	`197`
`201`	`198`	`var suppliedArgs = new object?[parameterTypes.Length];`
`202`	`199`
`203`		`- jsRuntime.ByteArrayJsonConverter.ByteArraysToDeserialize = byteArrays;`
	`200`	`+ jsRuntime.ByteArrayJsonConverter.ByteArraysToDeserialize = serializedArgs.ByteArrays;`
`204`	`201`
`205`	`202`	`var index = 0;`
`206`	`203`	`while (index < parameterTypes.Length && reader.Read() && reader.TokenType != JsonTokenType.EndArray)`
`@@ -263,15 +260,14 @@ static bool IsIncorrectDotNetObjectRefUse(Type parameterType, Utf8JsonReader jso`
`263`	`260`	`/// passed in as parameters.`
`264`	`261`	`/// </remarks>`
`265`	`262`	`/// <param name="jsRuntime">The <see cref="JSRuntime"/>.</param>`
`266`		`- /// <param name="arguments">The serialized arguments for the callback completion.</param>`
`267`		`- /// <param name="byteArrays">Byte array data extracted from the arguments for direct transfer.</param>`
	`263`	`+ /// <param name="serializedArgs">The serialized args containing the JSON representation along with the extracted byte arrays.</param>`
`268`	`264`	`/// <exception cref="Exception">`
`269`	`265`	`/// This method can throw any exception either from the argument received or as a result`
`270`	`266`	`/// of executing any callback synchronously upon completion.`
`271`	`267`	`/// </exception>`
`272`		`- public static void EndInvokeJS(JSRuntime jsRuntime, string arguments, byte[][]? byteArrays)`
	`268`	`+ public static void EndInvokeJS(JSRuntime jsRuntime, SerializedArgs serializedArgs)`
`273`	`269`	`{`
`274`		`- var utf8JsonBytes = Encoding.UTF8.GetBytes(arguments);`
	`270`	`+ var utf8JsonBytes = Encoding.UTF8.GetBytes(serializedArgs.ArgsJson ?? string.Empty);`
`275`	`271`
`276`	`272`	`// The payload that we're trying to parse is of the format`
`277`	`273`	`// [ taskId: long, success: boolean, value: string? \| object ]`
`@@ -292,7 +288,7 @@ public static void EndInvokeJS(JSRuntime jsRuntime, string arguments, byte[][]?`
`292`	`288`	`var success = reader.GetBoolean();`
`293`	`289`
`294`	`290`	`reader.Read();`
`295`		`- jsRuntime.EndInvokeJS(taskId, success, ref reader, byteArrays);`
	`291`	`+ jsRuntime.EndInvokeJS(taskId, success, ref reader, serializedArgs.ByteArrays);`
`296`	`292`
`297`	`293`	`if (!reader.Read() \|\| reader.TokenType != JsonTokenType.EndArray)`
`298`	`294`	`{`