More progress

ejsmith · ejsmith · commit 1275c40796d9 · 2025-08-02T12:58:29.000-05:00
diff --git a/src/Foundatio.Mediator.SourceGenerator/HandlerGenerator.cs b/src/Foundatio.Mediator.SourceGenerator/HandlerGenerator.cs
@@ -92,14 +92,14 @@ private static void GenerateHandleMethod(IndentedStringBuilder source, HandlerIn
         string stronglyTypedMethodName = GetHandlerMethodName(handler);
 
         string asyncModifier = handler.IsAsync ? "async " : "";
-        string result, accessor, parameters;
+        string result, accessor, parameters, defaultValue;
         string returnType = handler.ReturnType.FullName;
 
         var variables = new Dictionary<string, string>();
 
         var beforeMiddleware = handler.Middleware.Where(m => m.BeforeMethod != null).Select(m => (Method: m.BeforeMethod!.Value, Middleware: m)).ToList();
-        var afterMiddleware = handler.Middleware.Where(m => m.AfterMethod != null).Select(m => (Method: m.AfterMethod!.Value, Middleware: m)).ToList();
-        var finallyMiddleware = handler.Middleware.Where(m => m.FinallyMethod != null).Select(m => (Method: m.FinallyMethod!.Value, Middleware: m)).ToList();
+        var afterMiddleware = handler.Middleware.Where(m => m.AfterMethod != null).Reverse().Select(m => (Method: m.AfterMethod!.Value, Middleware: m)).ToList();
+        var finallyMiddleware = handler.Middleware.Where(m => m.FinallyMethod != null).Reverse().Select(m => (Method: m.FinallyMethod!.Value, Middleware: m)).ToList();
 
         var shouldUseTryCatch = finallyMiddleware.Any();
 
@@ -124,38 +124,44 @@ private static void GenerateHandleMethod(IndentedStringBuilder source, HandlerIn
         // build middleware instances
         foreach (var m in handler.Middleware.Where(m => m.IsStatic == false))
         {
-            source.AppendLine($"var middleware{m.Identifier} = global::Foundatio.Mediator.Mediator.GetOrCreateMiddleware<{m.FullName}>(serviceProvider);");
+            source.AppendLine($"var {m.Identifier.ToCamelCase()} = global::Foundatio.Mediator.Mediator.GetOrCreateMiddleware<{m.FullName}>(serviceProvider);");
         }
 
         source.AppendLine();
 
         // build result variables for before methods
         foreach (var m in beforeMiddleware.Where(m => m.Method.HasReturnValue))
         {
-            var defaultValue = m.Method.ReturnType.IsNullable ? "null" : "default";
-            source.AppendLine($"global::{m.Method.ReturnType.FullName} result{m.Middleware.Identifier} = {defaultValue};");
+            bool allowNull = m.Method.ReturnType.IsNullable || m.Method.ReturnType.IsReferenceType;
+            defaultValue = allowNull ? "null" : "default";
+            var prefix = m.Method.ReturnType.IsTuple ? "" : "global::";
+            source.AppendLine($"{prefix}{m.Method.ReturnType.FullName}{(allowNull ? "?" : "")} {m.Middleware.Identifier.ToCamelCase()}Result = {defaultValue};");
         }
 
         source.AppendLine();
+        defaultValue = handler.ReturnType.IsNullable ? "null" : "default";
+        source.AppendLine($"{handler.ReturnType.UnwrappedFullName} handlerResult = {defaultValue};");
 
         if (shouldUseTryCatch)
         {
             source.AppendLine("""
-                global::System.Exception? exception = null;");
+                global::System.Exception? exception = null;
 
                 try
                 {
                 """);
 
+            variables["System.Exception"] = "exception";
+
             source.IncrementIndent();
         }
 
         // call before middleware
         foreach (var m in beforeMiddleware)
         {
             asyncModifier = m.Middleware.IsAsync ? "await " : "";
-            result = m.Method.ReturnType.IsVoid ? "" : $"result{m.Middleware.Identifier} = ";
-            accessor = m.Middleware.IsStatic ? m.Middleware.FullName : $"middleware{m.Middleware.Identifier}";
+            result = m.Method.ReturnType.IsVoid ? "" : $"{m.Middleware.Identifier.ToCamelCase()}Result = ";
+            accessor = m.Middleware.IsStatic ? m.Middleware.FullName : $"{m.Middleware.Identifier.ToCamelCase()}";
             parameters = BuildParameters(m.Method.Parameters);
 
             source.AppendLine($"{result}{asyncModifier}{accessor}.{m.Method.MethodName}({parameters});");
@@ -164,24 +170,27 @@ private static void GenerateHandleMethod(IndentedStringBuilder source, HandlerIn
 
         // call handler
         asyncModifier = handler.IsAsync ? "await " : "";
-        result = handler.ReturnType.IsVoid ? "" : $"var handlerResult = ";
+        result = handler.ReturnType.IsVoid ? "" : shouldUseTryCatch ? "handlerResult = " : "return ";
         accessor = handler.IsStatic ? handler.FullName : $"handlerInstance";
         parameters = BuildParameters(handler.Parameters);
+
         source.AppendLineIf("var handlerInstance = GetOrCreateHandler(serviceProvider);", !handler.IsStatic);
         source.AppendLine($"{result}{asyncModifier}{accessor}.{handler.MethodName}({parameters});");
-        source.AppendLine();
+        source.AppendLineIf(handler.HasReturnValue);
 
         // call after middleware
         foreach (var m in afterMiddleware)
         {
             asyncModifier = m.Middleware.IsAsync ? "await " : "";
-            accessor = m.Middleware.IsStatic ? m.Middleware.FullName : $"middleware{m.Middleware.Identifier}";
-            parameters = BuildParameters(m.Method.Parameters);
+            accessor = m.Middleware.IsStatic ? m.Middleware.FullName : $"{m.Middleware.Identifier.ToCamelCase()}";
+            parameters = BuildParameters(m.Method.Parameters, variables);
 
             source.AppendLine($"{asyncModifier}{accessor}.{m.Method.MethodName}({parameters});");
         }
         source.AppendLineIf(afterMiddleware.Any());
 
+        source.AppendLineIf("return handlerResult;", handler.HasReturnValue);
+
         if (shouldUseTryCatch)
         {
             source.DecrementIndent();
@@ -203,30 +212,23 @@ private static void GenerateHandleMethod(IndentedStringBuilder source, HandlerIn
             foreach (var m in finallyMiddleware)
             {
                 asyncModifier = m.Method.IsAsync ? "await " : "";
-                accessor = m.Method.IsStatic ? m.Middleware.FullName : $"middleware{m.Middleware.Identifier}";
-                parameters = BuildParameters(m.Method.Parameters);
+                accessor = m.Method.IsStatic ? m.Middleware.FullName : $"{m.Middleware.Identifier.ToCamelCase()}";
+                parameters = BuildParameters(m.Method.Parameters, variables);
 
                 source.AppendLine($"{asyncModifier}{accessor}.{m.Method.MethodName}({parameters});");
             }
 
             source.DecrementIndent();
 
             source.AppendLine("}");
-            source.AppendLine();
-
-            source.DecrementIndent();
-        }
-
-        if (handler.HasReturnValue)
-        {
-            source.AppendLine("return handlerResult;");
         }
 
+        source.DecrementIndent();
         source.AppendLine("}");
         source.AppendLine();
     }
 
-    private static string BuildParameters(EquatableArray<ParameterInfo> parameters)
+    private static string BuildParameters(EquatableArray<ParameterInfo> parameters, Dictionary<string, string>? variables = null)
     {
         var parameterValues = new List<string>();
 
@@ -236,14 +238,25 @@ private static string BuildParameters(EquatableArray<ParameterInfo> parameters)
             {
                 parameterValues.Add("message");
             }
+            else if (param.Type.IsObject && param.Name == "handlerResult")
+            {
+                parameterValues.Add("handlerResult");
+            }
             else if (param.Type.IsCancellationToken)
             {
                 parameterValues.Add("cancellationToken");
             }
+            else if (variables != null && variables.TryGetValue(param.Type.FullName, out string? variableName))
+            {
+                parameterValues.Add(variableName);
+            }
+            else if (variables != null && variables.TryGetValue(param.Type.UnwrappedFullName, out string? unwrappedVariableName))
+            {
+                parameterValues.Add(unwrappedVariableName);
+            }
             else
             {
-                // This is a dependency that needs to be resolved from DI
-                parameterValues.Add($"serviceProvider.GetRequiredService<{param.Type.FullName}>()");
+                parameterValues.Add($"serviceProvider.GetRequiredService<global::{param.Type.FullName}>()");
             }
         }
 
diff --git a/src/Foundatio.Mediator.SourceGenerator/Models/TypeSymbolInfo.cs b/src/Foundatio.Mediator.SourceGenerator/Models/TypeSymbolInfo.cs
@@ -21,6 +21,10 @@ internal readonly record struct TypeSymbolInfo
     /// </summary>
     public bool IsNullable { get; init; }
     /// <summary>
+    /// Indicates if the type is a reference type, which means it is not a value type and can be null.
+    /// </summary>
+    public bool IsReferenceType { get; init; }
+    /// <summary>
     /// Indicates if the type is a Result type, which is a wrapper around a value that can be null or an error.
     /// </summary>
     public bool IsResult { get; init; }
@@ -65,6 +69,7 @@ public static TypeSymbolInfo From(ITypeSymbol typeSymbol, Compilation compilatio
         bool isTask = typeSymbol.IsTask(compilation);
         var unwrappedType = typeSymbol.UnwrapTask(compilation);
         bool isNullable = unwrappedType.IsNullable(compilation);
+        bool isReferenceType = unwrappedType.IsReferenceType;
         var unwrappedNullableType = unwrappedType.UnwrapNullable(compilation);
 
         // void or Task or ValueTask
@@ -84,6 +89,7 @@ public static TypeSymbolInfo From(ITypeSymbol typeSymbol, Compilation compilatio
             FullName = typeSymbol.ToDisplayString(),
             UnwrappedFullName = unwrappedType.ToDisplayString(),
             IsNullable = isNullable,
+            IsReferenceType = isReferenceType,
             IsResult = isResult,
             IsVoid = isVoid,
             IsTask = isTask,
diff --git a/src/Foundatio.Mediator.SourceGenerator/Utility/Helpers.cs b/src/Foundatio.Mediator.SourceGenerator/Utility/Helpers.cs
@@ -20,4 +20,12 @@ public static string ToIdentifier(this string name)
 
         return new String(name.Select(c => char.IsLetterOrDigit(c) || c == '_' ? c : '_').ToArray());
     }
+
+    public static string ToCamelCase(this string name)
+    {
+        if (string.IsNullOrEmpty(name))
+            return String.Empty;
+
+        return char.ToLower(name[0]) + name.Substring(1);
+    }
 }
diff --git a/src/Foundatio.Mediator.SourceGenerator/Utility/IndentedStringBuilder.cs b/src/Foundatio.Mediator.SourceGenerator/Utility/IndentedStringBuilder.cs
@@ -180,11 +180,40 @@ public virtual IndentedStringBuilder AppendLine()
     /// <returns>This builder so that additional calls can be chained.</returns>
     public virtual IndentedStringBuilder AppendLine(string value)
     {
-        if (value.Length != 0)
-            DoIndent();
+        if (value.Length == 0)
+        {
+            _stringBuilder.AppendLine();
+            _indentPending = true;
+            return this;
+        }
+
+        // Use StringReader to properly handle all line ending types
+        using var reader = new StringReader(value);
+        bool isFirstLine = true;
+
+        while (reader.ReadLine() is { } line)
+        {
+            if (!isFirstLine)
+            {
+                _stringBuilder.AppendLine();
+                _indentPending = true;
+            }
 
-        _stringBuilder.AppendLine(value);
+            if (line.Length > 0)
+            {
+                DoIndent();
+                _stringBuilder.Append(line);
+            }
+            else
+            {
+                // Empty line - just ensure indentation state is correct
+                _indentPending = true;
+            }
+
+            isFirstLine = false;
+        }
 
+        _stringBuilder.AppendLine();
         _indentPending = true;
 
         return this;
diff --git a/src/Foundatio.Mediator/HandlerRegistration.cs b/src/Foundatio.Mediator/HandlerRegistration.cs
@@ -12,7 +12,7 @@ public class HandlerRegistration
     /// <param name="handleAsync">The delegate to handle the message asynchronously</param>
     /// <param name="handle">The delegate to handle the message synchronously (null for async-only handlers)</param>
     /// <param name="isAsync">Whether the handler supports async operations</param>
-    public HandlerRegistration(string messageTypeName, Func<IMediator, object, CancellationToken, Type?, ValueTask<object?>> handleAsync, Func<IMediator, object, CancellationToken, Type?, object?>? handle, bool isAsync)
+    public HandlerRegistration(string messageTypeName, HandleAsyncDelegate handleAsync, HandleDelegate? handle, bool isAsync)
     {
         MessageTypeName = messageTypeName;
         HandleAsync = handleAsync;
@@ -28,15 +28,18 @@ public HandlerRegistration(string messageTypeName, Func<IMediator, object, Cance
     /// <summary>
     /// The delegate to handle the message
     /// </summary>
-    public Func<IMediator, object, CancellationToken, Type?, ValueTask<object?>> HandleAsync { get; }
+    public HandleAsyncDelegate HandleAsync { get; }
 
     /// <summary>
     /// The delegate to handle the message synchronously (null for async-only handlers)
     /// </summary>
-    public Func<IMediator, object, CancellationToken, Type?, object?>? Handle { get; }
+    public HandleDelegate? Handle { get; }
 
     /// <summary>
     /// Whether the handler supports async operations
     /// </summary>
     public bool IsAsync { get; }
 }
+
+public delegate ValueTask<object?> HandleAsyncDelegate(IMediator mediator, object message, CancellationToken cancellationToken, Type? returnType);
+public delegate object? HandleDelegate(IMediator mediator, object message, CancellationToken cancellationToken, Type? returnType);
diff --git a/src/Foundatio.Mediator/Mediator.cs b/src/Foundatio.Mediator/Mediator.cs
@@ -1,23 +1,13 @@
-#nullable enable
-
 using System.Collections.Concurrent;
 using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace Foundatio.Mediator;
 
-[ExcludeFromCodeCoverage]
 public class Mediator : IMediator, IServiceProvider
 {
     private readonly IServiceProvider _serviceProvider;
 
-    private static readonly ConcurrentDictionary<Type, Func<IMediator, object, CancellationToken, ValueTask>> _invokeAsyncCache = new();
-    private static readonly ConcurrentDictionary<Type, Func<IMediator, object, CancellationToken, object?>> _invokeCache = new();
-    private static readonly ConcurrentDictionary<(Type MessageType, Type ResponseType), Func<IMediator, object, CancellationToken, ValueTask<object?>>> _invokeAsyncWithResponseCache = new();
-    private static readonly ConcurrentDictionary<(Type MessageType, Type ResponseType), Func<IMediator, object, CancellationToken, object?>> _invokeWithResponseCache = new();
-    private static readonly ConcurrentDictionary<Type, Func<IMediator, object, CancellationToken, ValueTask<object?>>[]> _publishCache = new();
-
     [DebuggerStepThrough]
     public Mediator(IServiceProvider serviceProvider)
     {
@@ -28,7 +18,7 @@ public Mediator(IServiceProvider serviceProvider)
     public object? GetService(Type serviceType) => _serviceProvider.GetService(serviceType);
 
     [DebuggerStepThrough]
-    private Func<IMediator, object, CancellationToken, ValueTask<object?>>[] GetAllApplicableHandlers(object message)
+    private PublishAsyncDelegate[] GetAllApplicableHandlers(object message)
     {
         var messageType = message.GetType();
 
@@ -57,7 +47,7 @@ public Mediator(IServiceProvider serviceProvider)
             }
 
             return allHandlers.Distinct()
-                .Select<HandlerRegistration, Func<IMediator, object, CancellationToken, ValueTask<object?>>>(h => (mediator, message, cancellationToken) => h.HandleAsync(mediator, message, cancellationToken, null)).ToArray();
+                .Select<HandlerRegistration, PublishAsyncDelegate>(h => async (mediator, message, cancellationToken) => await h.HandleAsync(mediator, message, cancellationToken, null)).ToArray();
         });
     }
 
@@ -129,7 +119,7 @@ public async ValueTask<TResponse> InvokeAsync<TResponse>(object message, Cancell
                 throw new InvalidOperationException($"Multiple handlers found for message type {key.MessageType.FullName}. Use PublishAsync for multiple handlers.");
 
             var handler = handlersList.First();
-            return async (mediator, msg, ct) => await handler.HandleAsync(mediator, msg, ct, key.ResponseType);
+            return (mediator, msg, ct) => handler.HandleAsync(mediator, msg, ct, key.ResponseType);
         });
 
         var result = await cachedFunc(this, message, cancellationToken);
@@ -189,4 +179,20 @@ public static T GetOrCreateMiddleware<T>(IServiceProvider serviceProvider) where
         return (T)_middlewareCache.GetOrAdd(typeof(T), type =>
             ActivatorUtilities.CreateInstance<T>(serviceProvider));
     }
+
+    private delegate ValueTask InvokeAsyncDelegate(IMediator mediator, object message, CancellationToken cancellationToken);
+    private static readonly ConcurrentDictionary<Type, InvokeAsyncDelegate> _invokeAsyncCache = new();
+
+    private delegate void InvokeDelegate(IMediator mediator, object message, CancellationToken cancellationToken);
+    private static readonly ConcurrentDictionary<Type, InvokeDelegate> _invokeCache = new();
+
+    private delegate ValueTask<object?> InvokeAsyncResponseDelegate(IMediator mediator, object message, CancellationToken cancellationToken);
+    private static readonly ConcurrentDictionary<(Type MessageType, Type ResponseType), InvokeAsyncResponseDelegate> _invokeAsyncWithResponseCache = new();
+
+    private delegate object? InvokeResponseDelegate(IMediator mediator, object message, CancellationToken cancellationToken);
+    private static readonly ConcurrentDictionary<(Type MessageType, Type ResponseType), InvokeResponseDelegate> _invokeWithResponseCache = new();
+
+    private delegate ValueTask PublishAsyncDelegate(IMediator mediator, object message, CancellationToken cancellationToken);
+    private static readonly ConcurrentDictionary<Type, PublishAsyncDelegate[]> _publishCache = new();
+
 }

Original file line number	Diff line number	Diff line change
`@@ -20,4 +20,12 @@ public static string ToIdentifier(this string name)`
`20`	`20`
`21`	`21`	`return new String(name.Select(c => char.IsLetterOrDigit(c) \|\| c == '_' ? c : '_').ToArray());`
`22`	`22`	`}`
	`23`	`+`
	`24`	`+ public static string ToCamelCase(this string name)`
	`25`	`+ {`
	`26`	`+ if (string.IsNullOrEmpty(name))`
	`27`	`+ return String.Empty;`
	`28`	`+`
	`29`	`+ return char.ToLower(name[0]) + name.Substring(1);`
	`30`	`+ }`
`23`	`31`	`}`