Throw meaningful exception when async JSInvokable method is called synchronously from JS

[iamcymentho]

Summary

Fixes #46811

When a [JSInvokable] method that returns Task or ValueTask is invoked synchronously from JavaScript via invokeMethod(), the raw Task/ValueTask object gets serialized, producing misleading JSON errors like:

• "SerializeTypeInstanceNotSupported, System.Action"
• "ConstructorContainsNullParameterNames, System.Threading.Tasks.Task'1"

These errors make debugging difficult as they are unrelated to the actual problem.

Changes

DotNetDispatcher.cs - In the Invoke() method (sync code path), added a check after InvokeSynchronously() returns to detect async return types (Task, ValueTask, ValueTask<T>). When detected, throws an InvalidOperationException with a clear message:

"The method 'MethodName' returns an asynchronous type and cannot be invoked synchronously from JavaScript. Use 'invokeMethodAsync' instead of 'invokeMethod'."

DotNetDispatcherTest.cs - Added 2 tests and 1 test helper:

• SyncInvokeOfAsyncMethod_Task_ThrowsMeaningfulException
• SyncInvokeOfAsyncMethod_ValueTask_ThrowsMeaningfulException
• InvokableAsyncReturningTask() - simple [JSInvokable] test method

Test results

All 148 JSInterop tests pass with 0 failures.

Test plan

• SyncInvokeOfAsyncMethod_Task - verifies Task-returning methods throw clear error
• SyncInvokeOfAsyncMethod_ValueTask - verifies ValueTask-returning methods throw clear error
• Full JSInterop test suite passes (148/148)

[Copilot]

Pull request overview

This PR improves the developer experience for JS interop by detecting when an async [JSInvokable] method is invoked via the synchronous JS path (invokeMethod()), and throwing a clear InvalidOperationException instead of letting Task/ValueTask be serialized into misleading JSON-related errors.

Changes:

• Add sync-path detection for Task, ValueTask, and ValueTask<T> return values in DotNetDispatcher.Invoke(), throwing a targeted error message.
• Add new unit tests covering sync invocation of Task-returning and ValueTask-returning [JSInvokable] methods.
• Add a small test helper [JSInvokable] method that returns Task.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 4 comments.

File	Description
src/JSInterop/Microsoft.JSInterop/src/Infrastructure/DotNetDispatcher.cs	Adds sync-path check for async return types and throws a clearer exception before serialization.
src/JSInterop/Microsoft.JSInterop/test/Infrastructure/DotNetDispatcherTest.cs	Adds tests to validate the new exception behavior for Task and ValueTask sync invocation.

[dotnet-policy-service]

Looks like this PR hasn't been active for some time and the codebase could have been changed in the meantime.
To make sure no conflicting changes have occurred, please rerun validation before merging. You can do this by leaving an /azp run comment here (requires commit rights), or by simply closing and reopening.

[ilonatommy]

Thank you for your contribution. A few optimization suggestions.

[ilonatommy]

Let's remove the comment, the code is self-explainatory.

[ilonatommy]

Suggested change

	if (syncResult is Task || syncResult is ValueTask)
	if (result is Task or ValueTask
	|| (result?.GetType() is { IsGenericType: true } resultType
	&& resultType.GetGenericTypeDefinition() == typeof(ValueTask<>)))

We can shorten it to one condition.

[ilonatommy]

In many cases we could even avoid invocation. If we added

private static bool IsAsyncMethod(MethodInfo methodInfo)
 {
     var returnType = methodInfo.ReturnType;
     return typeof(Task).IsAssignableFrom(returnType)
         || returnType == typeof(ValueTask)
         || (returnType.IsGenericType 
             && returnType.GetGenericTypeDefinition() == typeof(ValueTask<>));
 }

it would cover the most frequent cases and avoid side effects of calling the method. For tricky constructions like

[JSInvokable]
public static object Tricky() => Task.CompletedTask;

we could still keep the check of syncResult. Then we extract throwing to one method and call it in case async is detected in return type or in syncResult.