perf: reduce Refit.Reflection memory allocations

Cut allocations across the reflection request builder's per-request and
per-method-parse paths, behaviour-identical, guided by GcVerbose micro-benchmarks.

- Query subsystem: cache per-type query-property metadata and the attribute
  provider, cache the enumerable classification, drop the iterator, and parse an
  existing query string span-based without a NameValueCollection - object/collection
  query flatten down 69-82%.
- Object-path / multipart / headers: cache per-parameter attributes, build the
  route object-property lookup lazily, value-tuple bindings, emit static headers
  without a per-request copy.
- Cold parse: read each parameter's attributes in one GetCustomAttributes pass,
  cache the declared factory-method lookup (FindDeclaredMethod -> 0 B,
  BuildRestResultFuncForMethod -76%), lazy/presize the parameter maps.
- Add a Refit.Reflection.Benchmarks GcVerbose micro-benchmark project and a
  Refit.Reflection.Tests project pinning the request-builder contracts; widen the
  relevant private members to internal (fields stay private) for benchmarking.

End-to-end reflection request build is ~21% faster on a query-object method
(6.5 -> 5.2 us). No public API change; behaviour and serialised output unchanged.

Author: glennawatson

src/Refit.Reflection/CachedAttributeProvider.cs

@@ -0,0 +1,33 @@
+// Copyright (c) 2019-2026 ReactiveUI and Contributors. All rights reserved.
+// ReactiveUI and Contributors licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reflection;
+
+namespace Refit;
+
+/// <summary>Wraps an <see cref="ICustomAttributeProvider"/> and materializes its <see cref="QueryAttribute"/> lookup once
+/// so the URL parameter formatter, which re-reads the attribute for every formatted value, never re-materializes it from
+/// metadata.</summary>
+/// <param name="inner">The underlying provider (a parameter, property or type) to read attributes from.</param>
+/// <remarks>Only the <c>(typeof(QueryAttribute), inherit: true)</c> lookup the default formatter performs is cached; every
+/// other query delegates to <paramref name="inner"/>, so a custom formatter that reads other attributes sees exactly the
+/// same values it would from the original provider. The cached array holds immutable metadata attributes, so sharing it
+/// across format calls is behaviourally identical to re-reading it.</remarks>
+internal sealed class CachedAttributeProvider(ICustomAttributeProvider inner) : ICustomAttributeProvider
+{
+    /// <summary>The materialized <see cref="QueryAttribute"/> lookup, cached on first read.</summary>
+    private object[]? _queryAttributes;
+
+    /// <inheritdoc/>
+    public object[] GetCustomAttributes(bool inherit) => inner.GetCustomAttributes(inherit);
+
+    /// <inheritdoc/>
+    public object[] GetCustomAttributes(Type attributeType, bool inherit) =>
+        inherit && attributeType == typeof(QueryAttribute)
+            ? _queryAttributes ??= inner.GetCustomAttributes(typeof(QueryAttribute), true)
+            : inner.GetCustomAttributes(attributeType, inherit);
+
+    /// <inheritdoc/>
+    public bool IsDefined(Type attributeType, bool inherit) => inner.IsDefined(attributeType, inherit);
+}

src/Refit.Reflection/IQueryValueSink.cs

@@ -0,0 +1,14 @@
+// Copyright (c) 2019-2026 ReactiveUI and Contributors. All rights reserved.
+// ReactiveUI and Contributors licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace Refit;
+
+/// <summary>Receives formatted enumerable query values so they can be appended in place without an intermediate sequence
+/// or iterator state machine.</summary>
+internal interface IQueryValueSink
+{
+    /// <summary>Appends one formatted value.</summary>
+    /// <param name="value">The formatted value, or <see langword="null"/>.</param>
+    void Add(string? value);
+}

src/Refit.Reflection/MethodTableKey.cs

@@ -18,13 +18,13 @@ public MethodTableKey(string methodName, Type[] parameters, Type[] genericArgume
     }
 
     /// <summary>Gets the methods name.</summary>
-    private string MethodName { get; }
+    internal string MethodName { get; }
 
     /// <summary>Gets the Array containing the methods parameters.</summary>
-    private Type[] Parameters { get; }
+    internal Type[] Parameters { get; }
 
     /// <summary>Gets the Array containing the methods generic arguments.</summary>
-    private Type[] GenericArguments { get; }
+    internal Type[] GenericArguments { get; }
 
     /// <inheritdoc/>
     public override int GetHashCode()

src/Refit.Reflection/ParameterAttributeSet.cs

@@ -0,0 +1,25 @@
+// Copyright (c) 2019-2026 ReactiveUI and Contributors. All rights reserved.
+// ReactiveUI and Contributors licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace Refit;
+
+/// <summary>The request-shaping attributes read from a single method parameter in one metadata pass, so the request
+/// builder's construction classifies each parameter without re-enumerating its attribute records per lookup.</summary>
+/// <param name="Query">The parameter's <see cref="QueryAttribute"/>, or null.</param>
+/// <param name="Header">The parameter's <see cref="HeaderAttribute"/>, or null.</param>
+/// <param name="HeaderCollection">The parameter's <see cref="HeaderCollectionAttribute"/>, or null.</param>
+/// <param name="Property">The parameter's <see cref="PropertyAttribute"/>, or null.</param>
+/// <param name="Authorize">The parameter's <see cref="AuthorizeAttribute"/>, or null.</param>
+/// <param name="Body">The parameter's <see cref="BodyAttribute"/>, or null.</param>
+/// <param name="Url">The parameter's <see cref="UrlAttribute"/>, or null.</param>
+/// <param name="FormObject">The parameter's <see cref="FormObjectAttribute"/>, or null.</param>
+internal readonly record struct ParameterAttributeSet(
+    QueryAttribute? Query,
+    HeaderAttribute? Header,
+    HeaderCollectionAttribute? HeaderCollection,
+    PropertyAttribute? Property,
+    AuthorizeAttribute? Authorize,
+    BodyAttribute? Body,
+    UrlAttribute? Url,
+    FormObjectAttribute? FormObject);

src/Refit.Reflection/QueryMapEntrySink.cs

@@ -0,0 +1,14 @@
+// Copyright (c) 2019-2026 ReactiveUI and Contributors. All rights reserved.
+// ReactiveUI and Contributors licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace Refit;
+
+/// <summary>Appends formatted enumerable values as <see cref="QueryMapEntry"/> items under a fixed key.</summary>
+/// <param name="Entries">The list receiving the entries.</param>
+/// <param name="Key">The query key applied to every appended value.</param>
+internal readonly record struct QueryMapEntrySink(List<QueryMapEntry> Entries, string Key) : IQueryValueSink
+{
+    /// <inheritdoc/>
+    public void Add(string? value) => Entries.Add(new(Key, value));
+}

src/Refit.Reflection/QueryParameterEntrySink.cs

@@ -0,0 +1,14 @@
+// Copyright (c) 2019-2026 ReactiveUI and Contributors. All rights reserved.
+// ReactiveUI and Contributors licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+namespace Refit;
+
+/// <summary>Appends formatted enumerable values as <see cref="QueryParameterEntry"/> items under a fixed key.</summary>
+/// <param name="Entries">The list receiving the entries.</param>
+/// <param name="Key">The query key applied to every appended value.</param>
+internal readonly record struct QueryParameterEntrySink(List<QueryParameterEntry> Entries, string Key) : IQueryValueSink
+{
+    /// <inheritdoc/>
+    public void Add(string? value) => Entries.Add(new(Key, value));
+}

src/Refit.Reflection/QueryPropertyMetadata.cs

@@ -0,0 +1,19 @@
+// Copyright (c) 2019-2026 ReactiveUI and Contributors. All rights reserved.
+// ReactiveUI and Contributors licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reflection;
+
+namespace Refit;
+
+/// <summary>One readable public property of a query object, together with the attribute-derived facts the reflection
+/// request builder would otherwise re-read from metadata on every request.</summary>
+/// <param name="Property">The readable public instance property.</param>
+/// <param name="IsIgnored">Whether the property carries a serialization-ignore attribute and is always skipped.</param>
+/// <param name="QueryAttribute">The property's <see cref="Refit.QueryAttribute"/>, or <see langword="null"/> when absent.</param>
+/// <param name="AliasAttribute">The property's <see cref="AliasAsAttribute"/>, or <see langword="null"/> when absent.</param>
+internal readonly record struct QueryPropertyMetadata(
+    PropertyInfo Property,
+    bool IsIgnored,
+    QueryAttribute? QueryAttribute,
+    AliasAsAttribute? AliasAttribute);

src/Refit.Reflection/Refit.Reflection.csproj

@@ -12,6 +12,8 @@
 
   <ItemGroup>
     <InternalsVisibleTo Include="Refit.Tests"/>
+    <InternalsVisibleTo Include="Refit.Reflection.Tests"/>
+    <InternalsVisibleTo Include="Refit.Reflection.Benchmarks"/>
     <ProjectReference Include="..\Refit\Refit.csproj" PrivateAssets="Analyzers"/>
   </ItemGroup>
 

src/Refit.Reflection/RequestBuilderImplementation.Execution.cs

@@ -9,6 +9,26 @@ namespace Refit;
 /// <summary>Reflection-based request builder that turns Refit interface calls into HTTP requests.</summary>
 internal partial class RequestBuilderImplementation
 {
+    /// <summary>Gets the cancellation token declared by the interface method, if any.</summary>
+    /// <param name="restMethod">The rest method being invoked.</param>
+    /// <param name="paramList">The argument values for the call.</param>
+    /// <returns>The method's cancellation token, or <see cref="CancellationToken.None"/>.</returns>
+    internal static CancellationToken GetMethodCancellationToken(
+        RestMethodInfoInternal restMethod,
+        object[] paramList) =>
+        restMethod.CancellationToken is not null
+            ? GetCancellationToken(paramList)
+            : CancellationToken.None;
+
+    /// <summary>Determines whether the request body should be buffered before sending.</summary>
+    /// <param name="restMethod">The rest method being invoked.</param>
+    /// <param name="request">The built request message.</param>
+    /// <returns><see langword="true"/> if the body should be buffered; otherwise <see langword="false"/>.</returns>
+    internal static bool IsBodyBuffered(
+        RestMethodInfoInternal restMethod,
+        HttpRequestMessage request) =>
+        (restMethod.BodyParameterInfo?.Item2 ?? false) && request.Content is not null;
+
     /// <summary>Builds and streams the response for a method returning an asynchronous sequence.</summary>
     /// <typeparam name="T">The element type yielded to the caller.</typeparam>
     /// <param name="client">The HTTP client to send with.</param>
@@ -53,31 +73,11 @@ internal partial class RequestBuilderImplementation
         }
     }
 
-    /// <summary>Gets the cancellation token declared by the interface method, if any.</summary>
-    /// <param name="restMethod">The rest method being invoked.</param>
-    /// <param name="paramList">The argument values for the call.</param>
-    /// <returns>The method's cancellation token, or <see cref="CancellationToken.None"/>.</returns>
-    private static CancellationToken GetMethodCancellationToken(
-        RestMethodInfoInternal restMethod,
-        object[] paramList) =>
-        restMethod.CancellationToken is not null
-            ? GetCancellationToken(paramList)
-            : CancellationToken.None;
-
-    /// <summary>Determines whether the request body should be buffered before sending.</summary>
-    /// <param name="restMethod">The rest method being invoked.</param>
-    /// <param name="request">The built request message.</param>
-    /// <returns><see langword="true"/> if the body should be buffered; otherwise <see langword="false"/>.</returns>
-    private static bool IsBodyBuffered(
-        RestMethodInfoInternal restMethod,
-        HttpRequestMessage request) =>
-        (restMethod.BodyParameterInfo?.Item2 ?? false) && request.Content is not null;
-
     /// <summary>Builds a delegate that constructs and returns the request for a <c>Task&lt;HttpRequestMessage&gt;</c> method.</summary>
     /// <param name="restMethod">The rest method to build a delegate for.</param>
     /// <returns>A delegate that returns a task producing the built request without sending it.</returns>
     [RequiresDynamicCode("Serializing a body by runtime Type requires runtime generic method instantiation.")]
-    private Func<HttpClient, object[], object?> BuildRequestMessageFuncForMethod(
+    internal Func<HttpClient, object[], object?> BuildRequestMessageFuncForMethod(
         RestMethodInfoInternal restMethod) =>
         (client, paramList) => BuildRequestMessageWithoutSendingAsync(client, restMethod, paramList);
 
@@ -90,7 +90,7 @@ private static bool IsBodyBuffered(
     /// logging, or manual dispatch. Any configured async authorization token getter runs at dispatch time and is
     /// therefore not applied to a request obtained this way.</remarks>
     [RequiresDynamicCode("Serializing a body by runtime Type requires runtime generic method instantiation.")]
-    private Task<HttpRequestMessage> BuildRequestMessageWithoutSendingAsync(
+    internal Task<HttpRequestMessage> BuildRequestMessageWithoutSendingAsync(
         HttpClient client,
         RestMethodInfoInternal restMethod,
         object[] paramList)
@@ -113,7 +113,7 @@ private Task<HttpRequestMessage> BuildRequestMessageWithoutSendingAsync(
     /// <param name="cancellationToken">A token to cancel the request.</param>
     /// <returns>A task that completes when the request finishes.</returns>
     [RequiresDynamicCode("Serializing a body by runtime Type requires runtime generic method instantiation.")]
-    private async Task ExecuteVoidRequestAsync(
+    internal async Task ExecuteVoidRequestAsync(
         HttpClient client,
         RestMethodInfoInternal restMethod,
         object[] paramList,
@@ -154,7 +154,7 @@ await RequestExecutionHelpers.SendVoidAsync(
         "SST2307:Generic method type parameters should be inferable from the parameters",
         Justification = "Type parameter intentionally specified explicitly by callers.")]
     [RequiresDynamicCode("Serializing a body by runtime Type requires runtime generic method instantiation.")]
-    private async Task<T?> ExecuteRequestAsync<T, TBody>(
+    internal async Task<T?> ExecuteRequestAsync<T, TBody>(
         HttpClient client,
         RestMethodInfoInternal restMethod,
         object[] paramList,
@@ -192,7 +192,7 @@ await RequestExecutionHelpers.SendVoidAsync(
         Justification = "Type parameter intentionally specified explicitly by callers.")]
     [RequiresDynamicCode("Serializing a body by runtime Type requires runtime generic method instantiation.")]
     [ExcludeFromCodeCoverage]
-    private async IAsyncEnumerable<T?> ExecuteAsyncEnumerableRequestAsync<T>(
+    internal async IAsyncEnumerable<T?> ExecuteAsyncEnumerableRequestAsync<T>(
         HttpClient client,
         RestMethodInfoInternal restMethod,
         object[] paramList,
@@ -218,7 +218,7 @@ await RequestExecutionHelpers.SendVoidAsync(
         "SST2307:Generic method type parameters should be inferable from the parameters",
         Justification = "Type parameter intentionally specified explicitly by callers.")]
     [RequiresDynamicCode("Serializing a body by runtime Type requires runtime generic method instantiation.")]
-    private Func<HttpClient, CancellationToken, object[], Task<T?>> BuildCancellableTaskFuncForMethod<T, TBody>(
+    internal Func<HttpClient, CancellationToken, object[], Task<T?>> BuildCancellableTaskFuncForMethod<T, TBody>(
         RestMethodInfoInternal restMethod) =>
         async (client, ct, paramList) =>
         {
@@ -254,7 +254,7 @@ await RequestExecutionHelpers.SendVoidAsync(
         "Design",
         "SST2307:Generic method type parameters should be inferable from the parameters",
         Justification = "Type parameter intentionally specified explicitly by callers.")]
-    private Task<T?> SendAndProcessResponseAsync<T, TBody>(
+    internal Task<T?> SendAndProcessResponseAsync<T, TBody>(
         HttpClient client,
         RestMethodInfoInternal restMethod,
         HttpRequestMessage request,