perf: reduce dispatch overhead and adopt PolySharp polyfills

src/Directory.Build.props

@@ -36,8 +36,8 @@
     <None Include="$(RepoRoot)assets\RequestFlowIcon-256x256.png" Pack="true" PackagePath="icon.png" />
   </ItemGroup>
 
-  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0' or '$(TargetFramework)' == 'net462'">
-    <Compile Include="$(MSBuildThisFileDirectory)Compat\*.cs" LinkBase="Compat" />
+  <ItemGroup>
+    <PackageReference Include="PolySharp" Version="1.16.0" PrivateAssets="all" />
   </ItemGroup>
 
 </Project>

src/RequestFlow.Cqrs/CqrsDispatcher.cs

@@ -14,26 +14,23 @@ internal sealed class CqrsDispatcher(IRequestDispatcher dispatcher) : ICommandDi
     /// <inheritdoc />
     public Task<TResponse> SendAsync<TResponse>(ICommand<TResponse> command, CancellationToken cancellationToken = default)
     {
-        if (command is null)
-            throw new ArgumentNullException(nameof(command));
+        ThrowHelper.ThrowIfNull(command);
 
         return _dispatcher.SendAsync(command, cancellationToken);
     }
 
     /// <inheritdoc />
     public Task SendAsync(ICommand command, CancellationToken cancellationToken = default)
     {
-        if (command is null)
-            throw new ArgumentNullException(nameof(command));
+        ThrowHelper.ThrowIfNull(command);
 
         return _dispatcher.SendAsync(command, cancellationToken);
     }
 
     /// <inheritdoc />
     public Task<TResponse> SendAsync<TResponse>(IQuery<TResponse> query, CancellationToken cancellationToken = default)
     {
-        if (query is null)
-            throw new ArgumentNullException(nameof(query));
+        ThrowHelper.ThrowIfNull(query);
 
         return _dispatcher.SendAsync(query, cancellationToken);
     }

src/RequestFlow.Cqrs/CqrsStreamDispatcher.cs

@@ -14,8 +14,7 @@ internal sealed class CqrsStreamDispatcher(IStreamDispatcher dispatcher) : IStre
     /// <inheritdoc />
     public IAsyncEnumerable<TItem> Stream<TItem>(IStreamQuery<TItem> query, CancellationToken cancellationToken = default)
     {
-        if (query is null)
-            throw new ArgumentNullException(nameof(query));
+        ThrowHelper.ThrowIfNull(query);
 
         return _dispatcher.Stream(query, cancellationToken);
     }

src/RequestFlow.Cqrs/CqrsValueDispatcher.cs

@@ -15,8 +15,7 @@ public ValueTask<TResponse> SendAsync<TResponse>(
         IValueCommand<TResponse> command,
         CancellationToken cancellationToken = default)
     {
-        if (command is null)
-            throw new ArgumentNullException(nameof(command));
+        ThrowHelper.ThrowIfNull(command);
 
         return _dispatcher.SendAsync(command, cancellationToken);
     }
@@ -26,8 +25,7 @@ public ValueTask SendAsync(
         IValueCommand command,
         CancellationToken cancellationToken = default)
     {
-        if (command is null)
-            throw new ArgumentNullException(nameof(command));
+        ThrowHelper.ThrowIfNull(command);
 
         return _dispatcher.SendAsync(command, cancellationToken);
     }
@@ -37,8 +35,7 @@ public ValueTask<TResponse> SendAsync<TResponse>(
         IValueQuery<TResponse> query,
         CancellationToken cancellationToken = default)
     {
-        if (query is null)
-            throw new ArgumentNullException(nameof(query));
+        ThrowHelper.ThrowIfNull(query);
 
         return _dispatcher.SendAsync(query, cancellationToken);
     }

src/RequestFlow.Cqrs/ThrowHelper.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace RequestFlow.Cqrs;
+
+internal static class ThrowHelper
+{
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void ThrowIfNull(
+        [NotNull] object? argument,
+        [CallerArgumentExpression(nameof(argument))] string? paramName = null)
+    {
+        if (argument is null)
+            ArgumentNull(paramName);
+    }
+
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static void ArgumentNull(string? paramName) => throw new ArgumentNullException(paramName);
+}

src/RequestFlow/Dispatch/DispatchMap.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 #if NET8_0_OR_GREATER
 using System.Collections.Frozen;
@@ -16,6 +17,6 @@ internal sealed class DispatchMap(Dictionary<Type, RequestPlanBase> plans)
 #endif
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public bool TryGetPlanFor(Type requestType, out RequestPlanBase? plan)
+    public bool TryGetPlanFor(Type requestType, [NotNullWhen(true)] out RequestPlanBase? plan)
         => _plans.TryGetValue(requestType, out plan);
 }

src/RequestFlow/Dispatch/NullTaskGuard.cs

@@ -8,17 +8,17 @@ internal static class NullTaskGuard
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static Task<TResponse> FromHandler<TResponse>(Task<TResponse> task, Type requestType)
-        => task ?? throw new HandlerNullTaskException(requestType);
+        => task ?? ThrowHelper.HandlerNullTask<Task<TResponse>>(requestType);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static Task<TResponse> FromStage<TResponse>(Task<TResponse> task, Type stageType)
-        => task ?? throw new StageNullTaskException(stageType);
+        => task ?? ThrowHelper.StageNullTask<Task<TResponse>>(stageType);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static Task FromEventHandler(Task task, Type eventType, Type handlerType)
-        => task ?? throw new EventHandlerNullTaskException(eventType, handlerType);
+        => task ?? ThrowHelper.EventHandlerNullTask<Task>(eventType, handlerType);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static Task FromStrategy(Task task, Type strategyType)
-        => task ?? throw new EventStrategyNullTaskException(strategyType);
+        => task ?? ThrowHelper.EventStrategyNullTask<Task>(strategyType);
 }

src/RequestFlow/Dispatch/RequestDispatcher.cs

@@ -12,25 +12,24 @@ internal sealed class RequestDispatcher(DispatchMap map, IServiceProvider servic
     /// <inheritdoc />
     public Task<TResponse> SendAsync<TResponse>(IRequest<TResponse> request, CancellationToken cancellationToken = default)
     {
-        if (request is null)
-            throw new ArgumentNullException(nameof(request));
+        ThrowHelper.ThrowIfNull(request);
 
         Type requestType = request.GetType();
 
         if (!_map.TryGetPlanFor(requestType, out RequestPlanBase? plan))
-            throw new HandlerNotFoundException(requestType);
+            return ThrowHelper.HandlerNotFound<Task<TResponse>>(requestType);
 
         if (plan is not RequestPlan<TResponse> typedPlan)
-            throw new ResponseTypeMismatchException(requestType, expected: plan!.ResponseType, actual: typeof(TResponse));
+            return ThrowHelper.ResponseTypeMismatch<Task<TResponse>>(
+                requestType, expected: plan.ResponseType, actual: typeof(TResponse));
 
         return typedPlan.ExecuteAsync(request, _services, cancellationToken);
     }
 
     /// <inheritdoc />
     public Task SendAsync(IRequest request, CancellationToken cancellationToken = default)
     {
-        if (request is null)
-            throw new ArgumentNullException(nameof(request));
+        ThrowHelper.ThrowIfNull(request);
 
         return SendAsync<NoResult>(request, cancellationToken);
     }

src/RequestFlow/Dispatch/Streaming/NullStreamGuard.cs

@@ -8,9 +8,9 @@ internal static class NullStreamGuard
 {
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IAsyncEnumerable<TItem> FromHandler<TItem>(IAsyncEnumerable<TItem> stream, Type requestType)
-        => stream ?? throw new HandlerNullStreamException(requestType);
+        => stream ?? ThrowHelper.HandlerNullStream<IAsyncEnumerable<TItem>>(requestType);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IAsyncEnumerable<TItem> FromStage<TItem>(IAsyncEnumerable<TItem> stream, Type stageType)
-        => stream ?? throw new StageNullStreamException(stageType);
+        => stream ?? ThrowHelper.StageNullStream<IAsyncEnumerable<TItem>>(stageType);
 }

src/RequestFlow/Dispatch/Streaming/StreamDispatcher.cs

@@ -19,18 +19,32 @@ internal sealed class StreamDispatcher(DispatchMap map, IServiceProvider service
     public IAsyncEnumerable<TItem> Stream<TItem>(
         IStreamRequest<TItem> request, CancellationToken cancellationToken = default)
     {
-        if (request is null)
-            throw new ArgumentNullException(nameof(request));
+        ThrowHelper.ThrowIfNull(request);
 
         Type requestType = request.GetType();
 
         if (!_map.TryGetPlanFor(requestType, out RequestPlanBase? plan))
-            throw new HandlerNotFoundException(requestType);
+            return ThrowHelper.HandlerNotFound<IAsyncEnumerable<TItem>>(requestType);
 
         if (plan is not StreamPlan<TItem> streamPlan)
-            throw new ResponseTypeMismatchException(requestType, expected: plan!.ResponseType, actual: typeof(TItem));
+            return ThrowHelper.ResponseTypeMismatch<IAsyncEnumerable<TItem>>(
+                requestType, expected: plan.ResponseType, actual: typeof(TItem));
 
-        return Walk(streamPlan, request, _services, cancellationToken);
+        return cancellationToken.CanBeCanceled
+            ? Walk(streamPlan, request, _services, cancellationToken)
+            : WalkWithoutDispatchToken(streamPlan, request, _services);
+    }
+
+    private static async IAsyncEnumerable<TItem> WalkWithoutDispatchToken<TItem>(
+        StreamPlan<TItem> plan,
+        object request,
+        IServiceProvider services,
+        [EnumeratorCancellation] CancellationToken iterationToken = default)
+    {
+        await foreach (TItem item in plan.Execute(request, services, iterationToken).ConfigureAwait(false))
+        {
+            yield return item;
+        }
     }
 
     // The dispatch token arrives as a parameter and the iteration token through the attribute, so

src/RequestFlow/Dispatch/ThrowHelper.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace RequestFlow;
+
+internal static class ThrowHelper
+{
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void ThrowIfNull(
+        [NotNull] object? argument,
+        [CallerArgumentExpression(nameof(argument))] string? paramName = null)
+    {
+        if (argument is null)
+            ArgumentNull(paramName);
+    }
+
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static void ArgumentNull(string? paramName) => throw new ArgumentNullException(paramName);
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static TResult HandlerNotFound<TResult>(Type requestType)
+        => throw new HandlerNotFoundException(requestType);
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static TResult ResponseTypeMismatch<TResult>(Type requestType, Type expected, Type actual)
+        => throw new ResponseTypeMismatchException(requestType, expected, actual);
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static TResult EventNotRegistered<TResult>(Type eventType)
+        => throw new EventNotRegisteredException(eventType);
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static TResult HandlerNullTask<TResult>(Type requestType)
+        => throw new HandlerNullTaskException(requestType);
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static TResult StageNullTask<TResult>(Type stageType)
+        => throw new StageNullTaskException(stageType);
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static TResult EventHandlerNullTask<TResult>(Type eventType, Type handlerType)
+        => throw new EventHandlerNullTaskException(eventType, handlerType);
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static TResult EventStrategyNullTask<TResult>(Type strategyType)
+        => throw new EventStrategyNullTaskException(strategyType);
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static TResult HandlerNullStream<TResult>(Type requestType)
+        => throw new HandlerNullStreamException(requestType);
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static TResult StageNullStream<TResult>(Type stageType)
+        => throw new StageNullStreamException(stageType);
+}

src/RequestFlow/Dispatch/ValueTask/ValueRequestDispatcher.cs

@@ -15,18 +15,17 @@ public ValueTask<TResponse> SendAsync<TResponse>(
         IValueRequest<TResponse> request,
         CancellationToken cancellationToken = default)
     {
-        if (request is null)
-            throw new ArgumentNullException(nameof(request));
+        ThrowHelper.ThrowIfNull(request);
 
         Type requestType = request.GetType();
 
         if (!_map.TryGetPlanFor(requestType, out RequestPlanBase? plan))
-            throw new HandlerNotFoundException(requestType);
+            return ThrowHelper.HandlerNotFound<ValueTask<TResponse>>(requestType);
 
         if (plan is not ValueRequestPlan<TResponse> typedPlan)
-            throw new ResponseTypeMismatchException(
+            return ThrowHelper.ResponseTypeMismatch<ValueTask<TResponse>>(
                 requestType,
-                expected: plan!.ResponseType,
+                expected: plan.ResponseType,
                 actual: typeof(TResponse));
 
         return typedPlan.ExecuteAsync(request, _services, cancellationToken);
@@ -37,13 +36,12 @@ public ValueTask SendAsync(
         IValueRequest request,
         CancellationToken cancellationToken = default)
     {
-        if (request is null)
-            throw new ArgumentNullException(nameof(request));
+        ThrowHelper.ThrowIfNull(request);
 
         Type requestType = request.GetType();
 
         if (!_map.TryGetPlanFor(requestType, out RequestPlanBase? plan))
-            throw new HandlerNotFoundException(requestType);
+            return ThrowHelper.HandlerNotFound<ValueTask>(requestType);
 
         if (plan is ValueVoidRequestPlan voidPlan)
             return voidPlan.ExecuteVoidAsync(request, _services, cancellationToken);
@@ -52,9 +50,9 @@ public ValueTask SendAsync(
             return ValueNoResultBridge.Discard(
                 typedPlan.ExecuteAsync(request, _services, cancellationToken));
 
-        throw new ResponseTypeMismatchException(
+        return ThrowHelper.ResponseTypeMismatch<ValueTask>(
             requestType,
-            expected: plan!.ResponseType,
+            expected: plan.ResponseType,
             actual: typeof(NoResult));
     }
 }

src/RequestFlow/Events/EventMap.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 #if NET8_0_OR_GREATER
 using System.Collections.Frozen;
@@ -16,6 +17,6 @@ internal sealed class EventMap(Dictionary<Type, EventPlan> plans)
 #endif
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public bool TryGetPlanFor(Type eventType, out EventPlan? plan)
+    public bool TryGetPlanFor(Type eventType, [NotNullWhen(true)] out EventPlan? plan)
         => _plans.TryGetValue(eventType, out plan);
 }

src/RequestFlow/Events/EventPlanFactory.cs

@@ -43,7 +43,9 @@ private static EventPlan CreatePlan(
         if (strategyType == typeof(SequentialPublishStrategy))
             return new SequentialEventPlan(@event, entries);
         if (strategyType == typeof(ParallelPublishStrategy))
-            return new ParallelEventPlan(@event, entries);
+            return entries.Length == 1
+                ? new SequentialEventPlan(@event, entries)
+                : new ParallelEventPlan(@event, entries);
         if (strategyType == typeof(FailFastPublishStrategy))
             return new SequentialEventPlan(@event, entries, stopOnFirstFailure: true);
 

src/RequestFlow/Events/EventPublisher.cs

@@ -11,13 +11,12 @@ internal sealed class EventPublisher(EventMap map, IServiceProvider services) :
 
     public Task PublishAsync(IEvent @event, CancellationToken cancellationToken = default)
     {
-        if (@event is null)
-            throw new ArgumentNullException(nameof(@event));
+        ThrowHelper.ThrowIfNull(@event, nameof(@event));
 
         Type eventType = @event.GetType();
         if (!_map.TryGetPlanFor(eventType, out EventPlan? plan))
-            throw new EventNotRegisteredException(eventType);
+            return ThrowHelper.EventNotRegistered<Task>(eventType);
 
-        return plan!.ExecuteAsync(@event, _services, cancellationToken);
+        return plan.ExecuteAsync(@event, _services, cancellationToken);
     }
 }

tests/Directory.Build.props

@@ -32,8 +32,8 @@
     <Using Include="Xunit" />
   </ItemGroup>
 
-  <ItemGroup Condition="'$(TargetFramework)' == 'net462'">
-    <Compile Include="$(MSBuildThisFileDirectory)Compat\*.cs" LinkBase="Compat" />
+  <ItemGroup>
+    <PackageReference Include="PolySharp" Version="1.16.0" PrivateAssets="all" />
   </ItemGroup>
 
 </Project>