perf: avoid FSharpValue.GetUnionFields in toParam via cached tag reader

Replace the FSharpValue.GetUnionFields call in toParam (used when
unwrapping F# option values for query/form parameters) with a
precomputed union-tag reader.

GetUnionFields allocates a UnionCaseInfo object and an obj[] on every
call. The new approach:
- Caches FSharpValue.PreComputeUnionTagReader per option type (O(1) tag
  check with no allocation after first call)
- Caches the Value PropertyInfo per option type (shared with
  unwrapFSharpOption)
- Removes the now-redundant private optionValuePropCache, consolidating
  both caches in one place

This matters for APIs that send many optional query/form parameters;
the improvement is visible when profiling clients that call high-
frequency endpoints with optional fields.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: github-actions[bot]

src/SwaggerProvider.Runtime/RuntimeHelpers.fs

@@ -111,6 +111,20 @@ module RuntimeHelpers =
     let private tryFormatTimeOnly(value: obj) =
         tryFormatViaMethods timeOnlyTypeName "HH:mm:ss.FFFFFFF" value
 
+    // Cache of precomputed union tag readers for F# option types. Avoids the overhead of
+    // FSharpValue.GetUnionFields (which allocates UnionCaseInfo + obj[]) on each call.
+    // Stores as (obj -> int) with an explicit wrapper to satisfy nullable annotations.
+    let private optionTagReaderCache =
+        Collections.Concurrent.ConcurrentDictionary<Type, obj -> int>()
+
+    let private makeOptionTagReader(t: Type) : obj -> int =
+        let reader = Microsoft.FSharp.Reflection.FSharpValue.PreComputeUnionTagReader t
+        fun (o: obj) -> reader o
+
+    // Cache of the 'Value' PropertyInfo per F# option type, shared with unwrapFSharpOption below.
+    let private optionValueCache =
+        Collections.Concurrent.ConcurrentDictionary<Type, Reflection.PropertyInfo>()
+
     let rec toParam(obj: obj) =
         match obj with
         | :? DateTime as dt -> dt.ToString("O")
@@ -125,15 +139,20 @@ module RuntimeHelpers =
                 | None ->
                     let ty = obj.GetType()
 
-                    // Unwrap F# Option<T>: Some(x) -> toParam(x), None -> null
+                    // Unwrap F# Option<T>: Some(x) -> toParam(x), None -> null.
+                    // Uses a precomputed tag reader (cached) to check Some/None without
+                    // allocating a UnionCaseInfo or obj[] on every call.
                     if
                         ty.IsGenericType
                         && ty.GetGenericTypeDefinition() = typedefof<option<_>>
                     then
-                        let (case, values) = Microsoft.FSharp.Reflection.FSharpValue.GetUnionFields(obj, ty)
+                        let tagReader =
+                            optionTagReaderCache.GetOrAdd(ty, System.Func<Type, obj -> int>(makeOptionTagReader))
+
+                        if tagReader obj = 1 then // 1 = Some
+                            let valueProp = optionValueCache.GetOrAdd(ty, fun t -> t.GetProperty("Value"))
 
-                        if case.Name = "Some" && values.Length > 0 then
-                            toParam values.[0]
+                            toParam(valueProp.GetValue(obj))
                         else
                             null
                     else
@@ -287,10 +306,7 @@ module RuntimeHelpers =
 
     // Unwraps F# option values: returns the inner value for Some, null for None.
     // This prevents `Some(value)` from being sent as-is in form data.
-    // The `Value` PropertyInfo is cached per concrete option type to avoid repeated reflection lookups.
-    let private optionValuePropCache =
-        Collections.Concurrent.ConcurrentDictionary<Type, Reflection.PropertyInfo>()
-
+    // Reuses optionValueCache defined alongside toParam above.
     let private unwrapFSharpOption(value: obj) : obj =
         if isNull value then
             null
@@ -301,7 +317,7 @@ module RuntimeHelpers =
                 ty.IsGenericType
                 && ty.GetGenericTypeDefinition() = typedefof<option<_>>
             then
-                let prop = optionValuePropCache.GetOrAdd(ty, fun t -> t.GetProperty("Value"))
+                let prop = optionValueCache.GetOrAdd(ty, fun t -> t.GetProperty("Value"))
                 prop.GetValue(value)
             else
                 value