Improved performance.

src/GeneratedEndpoints/AddEndpointHandlersGenerator.cs

@@ -0,0 +1,105 @@
+using System.Text;
+using GeneratedEndpoints.Common;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Text;
+using static GeneratedEndpoints.Common.Constants;
+
+namespace GeneratedEndpoints;
+
+// ReSharper disable ForCanBeConvertedToForeach
+// ReSharper disable LoopCanBeConvertedToQuery
+// Do not refactor, use for loop to avoid allocations.
+
+internal static class AddEndpointHandlersGenerator
+{
+    public static void GenerateSource(SourceProductionContext context, EquatableImmutableArray<RequestHandler> requestHandlers)
+    {
+        context.CancellationToken.ThrowIfCancellationRequested();
+
+        var nonStaticClassNames = GetDistinctNonStaticClassNames(requestHandlers);
+        var source = GetAddEndpointHandlersStringBuilder(nonStaticClassNames);
+        source.AppendLine(FileHeader);
+
+        source.AppendLine();
+
+        source.AppendLine("using Microsoft.Extensions.DependencyInjection;");
+        source.AppendLine("using Microsoft.Extensions.DependencyInjection.Extensions;");
+        source.AppendLine();
+
+        source.Append("namespace ");
+        source.Append(RoutingNamespace);
+        source.AppendLine(";");
+
+        source.AppendLine();
+
+        source.Append("internal static class ");
+        source.Append(AddEndpointHandlersClassName);
+        source.AppendLine();
+
+        source.AppendLine("{");
+
+        source.Append("    internal static void ");
+        source.Append(AddEndpointHandlersMethodName);
+        source.AppendLine("(this IServiceCollection services)");
+
+        source.AppendLine("    {");
+
+        foreach (var className in nonStaticClassNames)
+        {
+            source.Append("        services.TryAddScoped<");
+            source.Append(className);
+            source.Append(">();");
+            source.AppendLine();
+        }
+
+        source.AppendLine("""
+                              }
+                          }
+                          """
+        );
+
+        var sourceText = StringBuilderPool.ToStringAndReturn(source);
+        context.AddSource(AddEndpointHandlersMethodHint, SourceText.From(sourceText, Encoding.UTF8));
+    }
+
+    private static List<string> GetDistinctNonStaticClassNames(EquatableImmutableArray<RequestHandler> requestHandlers)
+    {
+        var classNames = new List<string>();
+        if (requestHandlers.Count == 0)
+            return classNames;
+
+        var seen = new HashSet<string>(StringComparer.Ordinal);
+        for (var index = 0; index < requestHandlers.Count; index++)
+        {
+            var requestHandler = requestHandlers[index];
+            if (requestHandler.Class.IsStatic)
+                continue;
+
+            var className = requestHandler.Class.Name;
+            if (seen.Add(className))
+                classNames.Add(className);
+        }
+
+        return classNames;
+    }
+
+    private static StringBuilder GetAddEndpointHandlersStringBuilder(List<string> nonStaticClassNames)
+    {
+        var estimate = 512L;
+        for (var index = 0; index < nonStaticClassNames.Count; index++)
+        {
+            var className = nonStaticClassNames[index];
+            estimate += 36 + className.Length;
+        }
+
+        estimate += Math.Max(256, nonStaticClassNames.Count * 12);
+        estimate = (long)(estimate * 1.10);
+
+        if (estimate < 512)
+            estimate = 512;
+        else if (estimate > int.MaxValue)
+            estimate = int.MaxValue;
+
+        return StringBuilderPool.Get((int)estimate);
+    }
+}

src/GeneratedEndpoints/Common/AcceptsMetadata.cs

@@ -0,0 +1,8 @@
+namespace GeneratedEndpoints.Common;
+
+internal readonly record struct AcceptsMetadata(
+    string RequestType,
+    string ContentType,
+    EquatableImmutableArray<string>? AdditionalContentTypes,
+    bool IsOptional
+);

src/GeneratedEndpoints/Common/AttributeDataExtensions.cs

@@ -0,0 +1,91 @@
+using Microsoft.CodeAnalysis;
+
+namespace GeneratedEndpoints.Common;
+
+internal static class AttributeDataExtensions
+{
+    public static string? GetConstructorStringValue(this AttributeData attribute, int position = 0)
+    {
+        if (attribute.ConstructorArguments.Length > position)
+            return (attribute.ConstructorArguments[position].Value as string).NormalizeOptionalString();
+
+        return null;
+    }
+
+    public static EquatableImmutableArray<string>? GetConstructorStringArray(this AttributeData attribute, int position = 0)
+    {
+        if (attribute.ConstructorArguments.Length <= position)
+            return null;
+
+        var arg = attribute.ConstructorArguments[position];
+        if (arg.Kind == TypedConstantKind.Array)
+        {
+            if (arg.Values.Length == 0)
+                return null;
+
+            List<string>? normalized = null;
+            foreach (var value in arg.Values)
+            {
+                if (value.Value is not string stringValue)
+                    continue;
+
+                var trimmed = stringValue.NormalizeOptionalString();
+                if (trimmed is not { Length: > 0 })
+                    continue;
+
+                normalized ??= new List<string>(arg.Values.Length);
+                normalized.Add(trimmed);
+            }
+
+            if (normalized is { Count: > 0 })
+                return normalized.ToEquatableImmutableArray();
+        }
+        else if (arg.Value is string singleHost && !string.IsNullOrWhiteSpace(singleHost))
+        {
+            return new[] { singleHost.Trim() }.ToEquatableImmutableArray();
+        }
+
+        return null;
+    }
+
+    public static int? GetConstructorIntValue(this AttributeData attribute, int position = 0)
+    {
+        if (attribute.ConstructorArguments.Length > position && attribute.ConstructorArguments[position].Value is int value)
+            return value;
+
+        return null;
+    }
+
+    public static ITypeSymbol? GetNamedTypeSymbol(this AttributeData attribute, string namedParameter)
+    {
+        foreach (var namedArg in attribute.NamedArguments)
+        {
+            if (namedArg.Key == namedParameter && namedArg.Value.Value is ITypeSymbol typeSymbol)
+                return typeSymbol;
+        }
+
+        return null;
+    }
+
+    public static bool GetNamedBoolValue(this AttributeData attribute, string namedParameter, bool defaultValue = false)
+    {
+        foreach (var namedArg in attribute.NamedArguments)
+        {
+            if (namedArg.Key == namedParameter && namedArg.Value.Value is bool boolValue)
+                return boolValue;
+        }
+
+        return defaultValue;
+    }
+
+    public static string? GetNamedStringValue(this AttributeData attribute, string namedParameter)
+    {
+        foreach (var namedArg in attribute.NamedArguments)
+        {
+            if (namedArg.Key == namedParameter && namedArg.Value.Value is string stringValue)
+                return stringValue.NormalizeOptionalString();
+        }
+
+        return null;
+    }
+}

src/GeneratedEndpoints/Common/AttributeSymbolMatcher.cs

@@ -0,0 +1,25 @@
+using Microsoft.CodeAnalysis;
+
+namespace GeneratedEndpoints.Common;
+
+internal static class AttributeSymbolMatcher
+{
+    public static bool IsAttribute(INamedTypeSymbol attributeClass, string attributeName, string[] namespaceParts)
+    {
+        var definition = attributeClass.OriginalDefinition;
+        return definition.Name == attributeName && IsInNamespace(definition.ContainingNamespace, namespaceParts);
+    }
+
+    public static bool IsInNamespace(INamespaceSymbol? namespaceSymbol, string[] namespaceParts)
+    {
+        for (var i = namespaceParts.Length - 1; i >= 0; i--)
+        {
+            if (namespaceSymbol is null || namespaceSymbol.Name != namespaceParts[i])
+                return false;
+
+            namespaceSymbol = namespaceSymbol.ContainingNamespace;
+        }
+
+        return namespaceSymbol is null || namespaceSymbol.IsGlobalNamespace;
+    }
+}

src/GeneratedEndpoints/Common/BindingSource.cs

@@ -0,0 +1,14 @@
+namespace GeneratedEndpoints.Common;
+
+internal enum BindingSource
+{
+    None = 0,
+    FromRoute = 1,
+    FromQuery = 2,
+    FromHeader = 3,
+    FromBody = 4,
+    FromForm = 5,
+    FromServices = 6,
+    FromKeyedServices = 7,
+    AsParameters = 8,
+}

src/GeneratedEndpoints/Common/ConfigureMethodDetails.cs

@@ -0,0 +1,3 @@
+namespace GeneratedEndpoints.Common;
+
+internal readonly record struct ConfigureMethodDetails(bool HasConfigureMethod, bool ConfigureMethodAcceptsServiceProvider);