diff --git a/eng/WpfArcadeSdk/tools/CodeGen/AvTrace/AvTraceMessages.tt b/eng/WpfArcadeSdk/tools/CodeGen/AvTrace/AvTraceMessages.tt
index ec25c00129e..d703a55d831 100644
--- a/eng/WpfArcadeSdk/tools/CodeGen/AvTrace/AvTraceMessages.tt
+++ b/eng/WpfArcadeSdk/tools/CodeGen/AvTrace/AvTraceMessages.tt
@@ -70,51 +70,15 @@ namespace MS.Internal
 <#		} #>
 
         /// <summary> Send a single trace output </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, params object[] parameters )
+        public static void Trace(TraceEventType type, AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2, object p3 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.Trace(type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         /// <summary> Send a singleton "activity" trace (really, this sends the same trace as both a Start and a Stop) </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails, params Object[] parameters )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2, object p3 )
+        public static void TraceActivityItem(AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.TraceStartStop(traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         public static bool IsEnabled
diff --git a/src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/Generated/AvTraceMessages.cs b/src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/Generated/AvTraceMessages.cs
index d368ae438e8..5a92955f3d6 100644
--- a/src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/Generated/AvTraceMessages.cs
+++ b/src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/Generated/AvTraceMessages.cs
@@ -69,51 +69,15 @@ public static AvTraceDetails InvokeHandlers
         }
 
         /// <summary> Send a single trace output </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, params object[] parameters )
+        public static void Trace(TraceEventType type, AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2, object p3 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.Trace(type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         /// <summary> Send a singleton "activity" trace (really, this sends the same trace as both a Start and a Stop) </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails, params Object[] parameters )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2, object p3 )
+        public static void TraceActivityItem(AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.TraceStartStop(traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         public static bool IsEnabled
@@ -252,51 +216,15 @@ public static AvTraceDetails AnimateStorageValidationNoLongerFailing
         }
 
         /// <summary> Send a single trace output </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, params object[] parameters )
+        public static void Trace(TraceEventType type, AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2, object p3 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.Trace(type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         /// <summary> Send a singleton "activity" trace (really, this sends the same trace as both a Start and a Stop) </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails, params Object[] parameters )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2, object p3 )
+        public static void TraceActivityItem(AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.TraceStartStop(traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         public static bool IsEnabled
diff --git a/src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/EventRoute.cs b/src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/EventRoute.cs
index f978b6b71b7..36c5cade467 100644
--- a/src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/EventRoute.cs
+++ b/src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/EventRoute.cs
@@ -168,31 +168,26 @@ private void InvokeHandlersImpl(object source, RoutedEventArgs args, bool reRais
                                 args.Source=newSource;
                         }
                     }
-                    
+
                     // Invoke listeners
 
-                    var traceRoutedEventIsEnabled = TraceRoutedEvent.IsEnabled;
-                    if ( traceRoutedEventIsEnabled )
+                    bool traceRoutedEventIsEnabled = TraceRoutedEvent.IsEnabled;
+                    if (traceRoutedEventIsEnabled)
                     {
-                        _traceArguments ??= new object[3];
-                        _traceArguments[0] = _routeItemList[i].Target;
-                        _traceArguments[1] = args;
-                        _traceArguments[2] = BooleanBoxes.Box(args.Handled);
                         TraceRoutedEvent.Trace(
                             TraceEventType.Start,
                             TraceRoutedEvent.InvokeHandlers,
-                            _traceArguments);
+                            _routeItemList[i].Target, args, BooleanBoxes.Box(args.Handled));
                     }
-                    
+
                     _routeItemList[i].InvokeHandler(args);
 
-                    if( traceRoutedEventIsEnabled )
+                    if (traceRoutedEventIsEnabled)
                     {
-                        _traceArguments[2] = BooleanBoxes.Box(args.Handled);
                         TraceRoutedEvent.Trace(
                             TraceEventType.Stop,
                             TraceRoutedEvent.InvokeHandlers,
-                            _traceArguments);
+                            _routeItemList[i].Target, args, BooleanBoxes.Box(args.Handled));
                     }
 
 
@@ -243,17 +238,13 @@ private void InvokeHandlersImpl(object source, RoutedEventArgs args, bool reRais
                         }
                         
                         
-                        var traceRoutedEventIsEnabled = TraceRoutedEvent.IsEnabled;
-                        if ( traceRoutedEventIsEnabled )
+                        bool traceRoutedEventIsEnabled = TraceRoutedEvent.IsEnabled;
+                        if (traceRoutedEventIsEnabled)
                         {
-                            _traceArguments ??= new object[3];
-                            _traceArguments[0] = _routeItemList[i].Target;
-                            _traceArguments[1] = args;
-                            _traceArguments[2] = BooleanBoxes.Box(args.Handled);
                             TraceRoutedEvent.Trace(
                                 TraceEventType.Start,
                                 TraceRoutedEvent.InvokeHandlers,
-                                _traceArguments);
+                                _routeItemList[i].Target, args, BooleanBoxes.Box(args.Handled));
                         }
 
                         // Invoke listeners
@@ -261,11 +252,10 @@ private void InvokeHandlersImpl(object source, RoutedEventArgs args, bool reRais
 
                         if (traceRoutedEventIsEnabled)
                         {
-                            _traceArguments[2] = BooleanBoxes.Box(args.Handled);
                             TraceRoutedEvent.Trace(
                                 TraceEventType.Stop,
                                 TraceRoutedEvent.InvokeHandlers,
-                                _traceArguments);
+                                _routeItemList[i].Target, args, BooleanBoxes.Box(args.Handled));
                         }
 
                     }
@@ -532,9 +522,6 @@ internal void Clear()
         // Stores Source Items for separated trees
         private FrugalStructList<SourceItem> _sourceItemList;
 
-        // Stores arguments that are passed to TraceRoutedEvent.Trace (to reduce allocations)
-        private object[] _traceArguments;
-
         #endregion Data
     }
 }
diff --git a/src/Microsoft.DotNet.Wpf/src/PresentationFramework/MS/Internal/Generated/AvTraceMessages.cs b/src/Microsoft.DotNet.Wpf/src/PresentationFramework/MS/Internal/Generated/AvTraceMessages.cs
index 043eb05102f..0ed99d94a36 100644
--- a/src/Microsoft.DotNet.Wpf/src/PresentationFramework/MS/Internal/Generated/AvTraceMessages.cs
+++ b/src/Microsoft.DotNet.Wpf/src/PresentationFramework/MS/Internal/Generated/AvTraceMessages.cs
@@ -1333,51 +1333,15 @@ public static AvTraceDetails XmlBuildCollection(params object[] args)
         }
 
         /// <summary> Send a single trace output </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, params object[] parameters )
+        public static void Trace(TraceEventType type, AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2, object p3 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.Trace(type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         /// <summary> Send a singleton "activity" trace (really, this sends the same trace as both a Start and a Stop) </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails, params Object[] parameters )
+        public static void TraceActivityItem(AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2, object p3 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.TraceStartStop(traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         public static bool IsEnabled
@@ -1460,51 +1424,15 @@ public static AvTraceDetails UnableToFreezeAnimatedProperties
         }
 
         /// <summary> Send a single trace output </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, params object[] parameters )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2, object p3 )
+        public static void Trace(TraceEventType type, AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.Trace(type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         /// <summary> Send a singleton "activity" trace (really, this sends the same trace as both a Start and a Stop) </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails, params Object[] parameters )
+        public static void TraceActivityItem(AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2, object p3 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.TraceStartStop(traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         public static bool IsEnabled
@@ -1699,51 +1627,15 @@ public static AvTraceDetails SetKey
         }
 
         /// <summary> Send a single trace output </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, params object[] parameters )
+        public static void Trace(TraceEventType type, AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2, object p3 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.Trace(type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         /// <summary> Send a singleton "activity" trace (really, this sends the same trace as both a Start and a Stop) </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails, params Object[] parameters )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2, object p3 )
+        public static void TraceActivityItem(AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.TraceStartStop(traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         public static bool IsEnabled
@@ -1994,51 +1886,15 @@ public static AvTraceDetails TypeConvertFallback
         }
 
         /// <summary> Send a single trace output </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, params object[] parameters )
+        public static void Trace(TraceEventType type, AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2, object p3 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.Trace(type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         /// <summary> Send a singleton "activity" trace (really, this sends the same trace as both a Start and a Stop) </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails, params Object[] parameters )
+        public static void TraceActivityItem(AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2, object p3 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.TraceStartStop(traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         public static bool IsEnabled
@@ -2079,51 +1935,15 @@ public static AvTraceDetails HwndHostIn3D
         }
 
         /// <summary> Send a single trace output </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, params object[] parameters )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2, object p3 )
+        public static void Trace(TraceEventType type, AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.Trace(type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         /// <summary> Send a singleton "activity" trace (really, this sends the same trace as both a Start and a Stop) </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails, params Object[] parameters )
+        public static void TraceActivityItem(AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2, object p3 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.TraceStartStop(traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         public static bool IsEnabled
@@ -2240,51 +2060,15 @@ public static AvTraceDetails RejectingJumpListCategoryBecauseNoRegisteredHandler
         }
 
         /// <summary> Send a single trace output </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, params object[] parameters )
+        public static void Trace(TraceEventType type, AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2, object p3 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.Trace(type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         /// <summary> Send a singleton "activity" trace (really, this sends the same trace as both a Start and a Stop) </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails, params Object[] parameters )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2, object p3 )
+        public static void TraceActivityItem(AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.TraceStartStop(traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         public static bool IsEnabled
diff --git a/src/Microsoft.DotNet.Wpf/src/PresentationFramework/MS/Internal/TraceData.cs b/src/Microsoft.DotNet.Wpf/src/PresentationFramework/MS/Internal/TraceData.cs
index 3a807ba77d7..5e7ef35f3d6 100644
--- a/src/Microsoft.DotNet.Wpf/src/PresentationFramework/MS/Internal/TraceData.cs
+++ b/src/Microsoft.DotNet.Wpf/src/PresentationFramework/MS/Internal/TraceData.cs
@@ -87,22 +87,22 @@ public static bool IsExtendedTraceEnabled(object element, TraceDataLevel level)
         }
 
         // report/describe any additional parameters passed to TraceData.Trace()
-        public static void OnTrace( AvTraceBuilder traceBuilder, object[] parameters, int start )
+        public static void OnTrace(AvTraceBuilder traceBuilder, ReadOnlySpan<object> parameters)
         {
-            for( int i = start; i < parameters.Length; i++ )
+            for (int i = 0; i < parameters.Length; i++)
             {
-                object o = parameters[i];
-                string s = o as string;
+                object objectParam = parameters[i];
                 traceBuilder.Append(" ");
-                if (s != null)
+
+                if (objectParam is string stringValue)
                 {
-                    traceBuilder.Append(s);
+                    traceBuilder.Append(stringValue);
                 }
-                else if (o != null)
+                else if (objectParam is not null)
                 {
-                    traceBuilder.Append(o.GetType().Name);
+                    traceBuilder.Append(objectParam.GetType().Name);
                     traceBuilder.Append(":");
-                    Describe(traceBuilder, o);
+                    Describe(traceBuilder, objectParam);
                 }
                 else
                 {
diff --git a/src/Microsoft.DotNet.Wpf/src/WindowsBase/MS/Internal/AvTrace.cs b/src/Microsoft.DotNet.Wpf/src/WindowsBase/MS/Internal/AvTrace.cs
index 10d2f6dac87..ccc859647d0 100644
--- a/src/Microsoft.DotNet.Wpf/src/WindowsBase/MS/Internal/AvTrace.cs
+++ b/src/Microsoft.DotNet.Wpf/src/WindowsBase/MS/Internal/AvTrace.cs
@@ -11,6 +11,7 @@
 
 using System.Globalization;
 using System.Text;
+using System.Reflection;
 using System.Collections;
 using System.Windows;
 
@@ -245,110 +246,95 @@ internal static bool IsDebuggerAttached()
         //  note: labels start at index 1, parameters start at index 0
         //
 
-        public string Trace( TraceEventType type, int eventId, string message, string[] labels, object[] parameters )
+        public string Trace(TraceEventType type, int eventId, string message, string[] labels, params ReadOnlySpan<object> parameters)
         {
             // Don't bother building the string if this trace is going to be ignored.
-
-            if( _traceSource == null
-                || !_traceSource.Switch.ShouldTrace( type ))
-            {
+            if (_traceSource is null || !_traceSource.Switch.ShouldTrace(type))
                 return null;
-            }
-
 
             // Compose the trace string.
-
             AvTraceBuilder traceBuilder = new AvTraceBuilder(AntiFormat(message)); // Holds the format string
-            ArrayList arrayList = new ArrayList(); // Holds the combined labels & parameters arrays.
-
+            object[] combinedArgs = null; // Holds the combined labels & parameters arrays.
             int formatIndex = 0;
 
-            if (parameters != null && labels != null && labels.Length > 0)
+            if (!parameters.IsEmpty && labels?.Length > 0)
             {
+                // Create array of pre-computed size
+                int combinedArgsLength = Math.Min(labels.Length - 1, parameters.Length) * 2;
+                if (combinedArgsLength > 0)
+                    combinedArgs = new object[combinedArgsLength];
+
                 int i = 1, j = 0;
-                for( ; i < labels.Length && j < parameters.Length; i++, j++ )
+                for (; i < labels.Length && j < parameters.Length; i++, j++)
                 {
-                    // Append to the format string a "; {0} = '{1}'", where the index increments (e.g. the second iteration will
-                    // produce {2} & {3}).
-
-                    traceBuilder.Append("; {" + (formatIndex++).ToString() + "}='{" + (formatIndex++).ToString() + "}'" );
+                    // Append to the format string a "; {0} = '{1}'", where the index increments
+                    // (e.g. the second iteration will produce {2} & {3}).
+                    traceBuilder.Append($"; {{{formatIndex++}}}='{{{formatIndex++}}}'");
 
-                    // If this parameter is null, convert to "<null>"; otherwise, when a string.format is ultimately called
-                    // it produces bad results.
+                    // Add the label to the combined list.
+                    combinedArgs[j * 2] = labels[i];
 
-                    if( parameters[j] == null )
+                    // If the parameter is null, convert to "<null>"; otherwise,
+                    // when a string.format is ultimately called it produces bad results.
+                    if (parameters[j] is null)
                     {
-                        parameters[j] = "<null>";
+                        combinedArgs[j * 2 + 1] = "<null>";
                     }
 
                     // Otherwise, if this is an interesting object, add the hash code and type to
-                    // the format string explicitely.
-
-                    else if( !SuppressGeneratedParameters
+                    // the format string explicitly.
+                    else if (!SuppressGeneratedParameters
                              && parameters[j].GetType() != typeof(string)
-                             && !(parameters[j] is ValueType)
-                             && !(parameters[j] is Type)
-                             && !(parameters[j] is DependencyProperty) )
+                             && parameters[j] is not ValueType
+                             && parameters[j] is not Type
+                             && parameters[j] is not DependencyProperty)
                     {
-                        traceBuilder.Append("; " + labels[i].ToString() + ".HashCode='"
-                                                    + GetHashCodeHelper(parameters[j]).ToString() + "'" );
+                        traceBuilder.Append($"; {labels[i]}.HashCode='{GetHashCodeHelper(parameters[j])}'");
+                        traceBuilder.Append($"; {labels[i]}.Type='{GetTypeHelper(parameters[j])}'");
 
-                        traceBuilder.Append("; " + labels[i].ToString() + ".Type='"
-                                                    + GetTypeHelper(parameters[j]).ToString() + "'" );
+                        // Add the parameter to the combined list.
+                        combinedArgs[j * 2 + 1] = parameters[j];
+                    }
+                    // Add the parameter to the combined list.
+                    else
+                    {
+                        combinedArgs[j * 2 + 1] = parameters[j];
                     }
-
-
-                    // Add the label & parameter to the combined list.
-                    // (As an optimization, the generated classes could pre-allocate a thread-safe static array, to avoid
-                    // this allocation and the ToArray allocation below.)
-
-                    arrayList.Add( labels[i] );
-                    arrayList.Add( parameters[j] );
                 }
 
-                // It's OK if we terminate because we have more lables than parameters;
+                // It's OK if we terminate because we have more labels than parameters;
                 // this is used by traces to have out-values in the Stop message.
-
-                if( TraceExtraMessages != null && j < parameters.Length)
+                if (TraceExtraMessages is not null && j < parameters.Length)
                 {
-                    TraceExtraMessages( traceBuilder, parameters, j );
+                    TraceExtraMessages(traceBuilder, parameters.Slice(j));
                 }
             }
 
             // Send the trace
 
             string traceMessage = traceBuilder.ToString();
-
-            _traceSource.TraceEvent(
-                type,
-                eventId,
-                traceMessage,
-                arrayList.ToArray() );
+            _traceSource.TraceEvent(type, eventId, traceMessage, combinedArgs);
 
             // When in the debugger, always flush the output, to guarantee that the
             // traces and other info (e.g. exceptions) get interleaved correctly.
 
-            if( IsDebuggerAttached() )
-            {
+            if (IsDebuggerAttached())
                 _traceSource.Flush();
-            }
 
             return traceMessage;
         }
 
-
         //
         //  Trace an event, as both a TraceEventType.Start and TraceEventType.Stop.
         //  (information is contained in the Start event)
         //
 
-        public void TraceStartStop( int eventID, string message, string[] labels, Object[] parameters )
+        public void TraceStartStop(int eventID, string message, string[] labels, params ReadOnlySpan<object> parameters)
         {
-            Trace( TraceEventType.Start, eventID, message, labels, parameters );
-            _traceSource.TraceEvent( TraceEventType.Stop, eventID);
+            Trace(TraceEventType.Start, eventID, message, labels, parameters);
+            _traceSource.TraceEvent(TraceEventType.Stop, eventID);
         }
 
-
         //
         //  Convert the value to a string, even if the system conversion throws
         //  an exception.
@@ -506,7 +492,7 @@ public static Type GetTypeHelper(object value)
 
     }
 
-    internal delegate void AvTraceEventHandler(AvTraceBuilder traceBuilder, object[] parameters, int start);
+    internal delegate void AvTraceEventHandler(AvTraceBuilder traceBuilder, ReadOnlySpan<object> parameters);
 
     internal class AvTraceBuilder
     {
diff --git a/src/Microsoft.DotNet.Wpf/src/WindowsBase/MS/Internal/Generated/AvTraceMessages.cs b/src/Microsoft.DotNet.Wpf/src/WindowsBase/MS/Internal/Generated/AvTraceMessages.cs
index 7f70ca10bdb..b9e0546f60c 100644
--- a/src/Microsoft.DotNet.Wpf/src/WindowsBase/MS/Internal/Generated/AvTraceMessages.cs
+++ b/src/Microsoft.DotNet.Wpf/src/WindowsBase/MS/Internal/Generated/AvTraceMessages.cs
@@ -70,51 +70,15 @@ public static AvTraceDetails UpdateEffectiveValueStop
         }
 
         /// <summary> Send a single trace output </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, params object[] parameters )
+        public static void Trace(TraceEventType type, AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2, object p3 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.Trace(type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         /// <summary> Send a singleton "activity" trace (really, this sends the same trace as both a Start and a Stop) </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails, params Object[] parameters )
+        public static void TraceActivityItem(AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2, object p3 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.TraceStartStop(traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         public static bool IsEnabled
@@ -197,51 +161,15 @@ public static AvTraceDetails UnableToFreezeAnimatedProperties
         }
 
         /// <summary> Send a single trace output </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, params object[] parameters )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2, object p3 )
+        public static void Trace(TraceEventType type, AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.Trace(type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         /// <summary> Send a singleton "activity" trace (really, this sends the same trace as both a Start and a Stop) </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails, params Object[] parameters )
+        public static void TraceActivityItem(AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2, object p3 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.TraceStartStop(traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         public static bool IsEnabled
@@ -297,51 +225,15 @@ public static AvTraceDetails UnregisterName
         }
 
         /// <summary> Send a single trace output </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, params object[] parameters )
+        public static void Trace(TraceEventType type, AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void Trace( TraceEventType type, AvTraceDetails traceDetails, object p1, object p2, object p3 )
-        {
-            _avTrace.Trace( type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.Trace(type, traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         /// <summary> Send a singleton "activity" trace (really, this sends the same trace as both a Start and a Stop) </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails, params Object[] parameters )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters );
-        }
-
-        /// <summary> These help delay allocation of object array </summary>
-        public static void TraceActivityItem( AvTraceDetails traceDetails )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, Array.Empty<object>() );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2 )
-        {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2 } );
-        }
-        public static void TraceActivityItem( AvTraceDetails traceDetails, object p1, object p2, object p3 )
+        public static void TraceActivityItem(AvTraceDetails traceDetails, params ReadOnlySpan<object> parameters)
         {
-            _avTrace.TraceStartStop( traceDetails.Id, traceDetails.Message, traceDetails.Labels, new object[] { p1, p2, p3 } );
+            _avTrace.TraceStartStop(traceDetails.Id, traceDetails.Message, traceDetails.Labels, parameters);
         }
 
         public static bool IsEnabled