perf: Additional changes to mitigate PG-AOT dotnet/runtime issue #56309

jeromelaban · MartinZikmund · commit a688e0b3e862 · 2021-09-24T09:11:00.000+02:00
See unoplatform#7005 for additional details
diff --git a/src/Uno.Foundation.Runtime.WebAssembly/Interop/Runtime.wasm.cs b/src/Uno.Foundation.Runtime.WebAssembly/Interop/Runtime.wasm.cs
@@ -60,19 +60,30 @@ public static bool InvokeJSUnmarshalled(string functionIdentifier, IntPtr arg0)
 		{
 			if (_trace.IsEnabled)
 			{
-				using (WritePropertyEventTrace(TraceProvider.UnmarshalledInvokedStart, TraceProvider.UnmarshalledInvokedEnd, functionIdentifier))
-				{
-					var ret = InnerInvokeJSUnmarshalled(functionIdentifier, arg0, out var exception);
-
-					if(exception != null)
-					{
-						throw exception;
-					}
+				return InvokeJSUnmarshalledWithTrace(functionIdentifier, arg0);
+			}
+			else
+			{
+				var ret = InnerInvokeJSUnmarshalled(functionIdentifier, arg0, out var exception);
 
-					return ret;
+				if (exception != null)
+				{
+					throw exception;
 				}
+
+				return ret;
 			}
-			else
+		}
+
+		/// <remarks>
+		/// This method contains or is called by a try/catch containing method and
+		/// can be significantly slower than other methods as a result on WebAssembly.
+		/// See https://github.com/dotnet/runtime/issues/56309
+		/// </remarks>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static bool InvokeJSUnmarshalledWithTrace(string functionIdentifier, IntPtr arg0)
+		{
+			using (WritePropertyEventTrace(TraceProvider.UnmarshalledInvokedStart, TraceProvider.UnmarshalledInvokedEnd, functionIdentifier))
 			{
 				var ret = InnerInvokeJSUnmarshalled(functionIdentifier, arg0, out var exception);
 
@@ -93,17 +104,28 @@ internal static bool InvokeJSUnmarshalled(string functionIdentifier, IntPtr arg0
 		{
 			if (_trace.IsEnabled)
 			{
-				using (WritePropertyEventTrace(TraceProvider.UnmarshalledInvokedStart, TraceProvider.UnmarshalledInvokedEnd, functionIdentifier))
-				{
-					return InnerInvokeJSUnmarshalled(functionIdentifier, arg0, out exception);
-				}
+				return InvokeJSUnmarshalledWithTrace(functionIdentifier, arg0, out exception);
 			}
 			else
 			{
 				return InnerInvokeJSUnmarshalled(functionIdentifier, arg0, out exception);
 			}
 		}
 
+		/// <remarks>
+		/// This method contains or is called by a try/catch containing method and
+		/// can be significantly slower than other methods as a result on WebAssembly.
+		/// See https://github.com/dotnet/runtime/issues/56309
+		/// </remarks>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static bool InvokeJSUnmarshalledWithTrace(string functionIdentifier, IntPtr arg0, out Exception? exception)
+		{
+			using (WritePropertyEventTrace(TraceProvider.UnmarshalledInvokedStart, TraceProvider.UnmarshalledInvokedEnd, functionIdentifier))
+			{
+				return InnerInvokeJSUnmarshalled(functionIdentifier, arg0, out exception);
+			}
+		}
+
 		private static bool InnerInvokeJSUnmarshalled(string functionIdentifier, IntPtr arg0, out Exception? exception)
 		{
 			exception = null;
@@ -135,17 +157,28 @@ public static bool InvokeJSUnmarshalled(string functionIdentifier, IntPtr arg0,
 		{
 			if (_trace.IsEnabled)
 			{
-				using (WritePropertyEventTrace(TraceProvider.UnmarshalledInvokedStart, TraceProvider.UnmarshalledInvokedEnd, functionIdentifier))
-				{
-					return InnerInvokeJSUnmarshalled(functionIdentifier, arg0, arg1);
-				}
+				return InvokeJSUnmarshalledWithTrace(functionIdentifier, arg0, arg1);
 			}
 			else
 			{
 				return InnerInvokeJSUnmarshalled(functionIdentifier, arg0, arg1);
 			}
 		}
 
+		/// <remarks>
+		/// This method contains or is called by a try/catch containing method and
+		/// can be significantly slower than other methods as a result on WebAssembly.
+		/// See https://github.com/dotnet/runtime/issues/56309
+		/// </remarks>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static bool InvokeJSUnmarshalledWithTrace(string functionIdentifier, IntPtr arg0, IntPtr arg1)
+		{
+			using (WritePropertyEventTrace(TraceProvider.UnmarshalledInvokedStart, TraceProvider.UnmarshalledInvokedEnd, functionIdentifier))
+			{
+				return InnerInvokeJSUnmarshalled(functionIdentifier, arg0, arg1);
+			}
+		}
+
 		private static bool InnerInvokeJSUnmarshalled(string functionIdentifier, IntPtr arg0, IntPtr arg1)
 		{
 			var methodId = GetMethodId(functionIdentifier);
@@ -179,10 +212,7 @@ public static string InvokeJS(string str)
 			{
 				if (_trace.IsEnabled)
 				{
-					using (WritePropertyEventTrace(TraceProvider.InvokeStart, TraceProvider.InvokeEnd, str))
-					{
-						return InnerInvokeJS(str);
-					}
+					return InvokeJSWithTrace(str);
 				}
 				else
 				{
@@ -203,6 +233,20 @@ public static string InvokeJS(string str)
 			}
 		}
 
+		/// <remarks>
+		/// This method contains or is called by a try/catch containing method and
+		/// can be significantly slower than other methods as a result on WebAssembly.
+		/// See https://github.com/dotnet/runtime/issues/56309
+		/// </remarks>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static string InvokeJSWithTrace(string str)
+		{
+			using (WritePropertyEventTrace(TraceProvider.InvokeStart, TraceProvider.InvokeEnd, str))
+			{
+				return InnerInvokeJS(str);
+			}
+		}
+
 		private static string InnerInvokeJS(String str)
 		{
 			if (_logger.Value.IsEnabled(LogLevel.Debug))
diff --git a/src/Uno.UI/DataBinding/BindingExpression.cs b/src/Uno.UI/DataBinding/BindingExpression.cs
@@ -541,23 +541,33 @@ private void SetTargetValueForXBindSelector()
 		{
 			try
 			{
-				var canSetTarget = _updateSources?.None(s => s.ValueType == null) ?? true;
-
-				if (canSetTarget)
-				{
-					SetTargetValueSafe(ParentBinding.XBindSelector(DataContext));
-				}
-				else
+				/// <remarks>
+				/// This method contains or is called by a try/catch containing method and
+				/// can be significantly slower than other methods as a result on WebAssembly.
+				/// See https://github.com/dotnet/runtime/issues/56309
+				/// </remarks>
+				void SetTargetValue()
 				{
-					// x:Bind failed bindings don't change the target value
-					// if no FallbackValue was specified.
-					ApplyFallbackValue(useTypeDefaultValue: false);
+					var canSetTarget = _updateSources?.None(s => s.ValueType == null) ?? true;
 
-					if (this.Log().IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug))
+					if (canSetTarget)
 					{
-						this.Log().Debug($"Binding path does not provide a value [{TargetPropertyDetails}] on [{_targetOwnerType}], using fallback value");
+						SetTargetValueSafe(ParentBinding.XBindSelector(DataContext));
+					}
+					else
+					{
+						// x:Bind failed bindings don't change the target value
+						// if no FallbackValue was specified.
+						ApplyFallbackValue(useTypeDefaultValue: false);
+
+						if (this.Log().IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug))
+						{
+							this.Log().Debug($"Binding path does not provide a value [{TargetPropertyDetails}] on [{_targetOwnerType}], using fallback value");
+						}
 					}
 				}
+
+				SetTargetValue();
 			}
 			catch (Exception e)
 			{
diff --git a/src/Uno.UI/UI/Xaml/DependencyObjectStore.Binder.cs b/src/Uno.UI/UI/Xaml/DependencyObjectStore.Binder.cs
@@ -298,11 +298,21 @@ private void OnDataContextChanged(object? providedDataContext, object? actualDat
 
 					if (TryWriteDataContextChangedEventActivity() is { } trace)
 					{
-						// "using" statements are costly under we https://github.com/dotnet/runtime/issues/50783
-						using (trace)
+						/// <remarks>
+						/// This method contains or is called by a try/catch containing method and
+						/// can be significantly slower than other methods as a result on WebAssembly.
+						/// See https://github.com/dotnet/runtime/issues/56309
+						/// </remarks>
+						void ApplyWithTrace (object? actualDataContext, IDisposable trace)
 						{
-							ApplyDataContext(actualDataContext);
+							using (trace)
+							{
+								ApplyDataContext(actualDataContext);
+							}
 						}
+
+						// "using" statements are costly under we https://github.com/dotnet/runtime/issues/50783
+						ApplyWithTrace(actualDataContext, trace);
 					}
 					else
 					{
diff --git a/src/Uno.UI/UI/Xaml/DependencyObjectStore.cs b/src/Uno.UI/UI/Xaml/DependencyObjectStore.cs
@@ -415,16 +415,25 @@ internal void SetValue(DependencyProperty property, object? value, DependencyPro
 		{
 			if (_trace.IsEnabled)
 			{
-				using (WritePropertyEventTrace(TraceProvider.SetValueStart, TraceProvider.SetValueStop, property, precedence))
+				/// <remarks>
+				/// This method contains or is called by a try/catch containing method and
+				/// can be significantly slower than other methods as a result on WebAssembly.
+				/// See https://github.com/dotnet/runtime/issues/56309
+				/// </remarks>
+				void SetValueWithTrace(DependencyProperty property, object? value, DependencyPropertyValuePrecedences precedence, DependencyPropertyDetails? propertyDetails, bool isThemeBinding)
 				{
-					InnerSetValue(property, value, precedence, propertyDetails, isThemeBinding);
+					using (WritePropertyEventTrace(TraceProvider.SetValueStart, TraceProvider.SetValueStop, property, precedence))
+					{
+						InnerSetValue(property, value, precedence, propertyDetails, isThemeBinding);
+					}
 				}
+
+				SetValueWithTrace(property, value, precedence, propertyDetails, isThemeBinding);
 			}
 			else
 			{
 				InnerSetValue(property, value, precedence, propertyDetails, isThemeBinding);
 			}
-
 		}
 
 		private void InnerSetValue(DependencyProperty property, object? value, DependencyPropertyValuePrecedences precedence, DependencyPropertyDetails? propertyDetails, bool isThemeBinding)
@@ -1000,8 +1009,12 @@ private void CleanupInheritedProperties()
 
 				if (ActualInstance != null)
 				{
-					foreach (var dp in _updatedProperties)
+					// This block is a manual enumeration to avoid the foreach pattern
+					// See https://github.com/dotnet/runtime/issues/56309 for details
+					var propertiesEnumerator = _updatedProperties.GetEnumerator();
+					while(propertiesEnumerator.MoveNext())
 					{
+						var dp = propertiesEnumerator.Current;
 						SetValue(dp, DependencyProperty.UnsetValue, DependencyPropertyValuePrecedences.Inheritance);
 					}
 
@@ -1367,8 +1380,13 @@ private void PropagateInheritedNonLocalProperties(DependencyObjectStore? childSt
 			// call to IsAncestor.
 			var actualInstanceAlias = ActualInstance;
 
-			foreach (var sourceInstanceProperties in _inheritedForwardedProperties)
+			// This block is a manual enumeration to avoid the foreach pattern
+			// See https://github.com/dotnet/runtime/issues/56309 for details
+			var forwardedEnumerator = _inheritedForwardedProperties.GetEnumerator();
+			while(forwardedEnumerator.MoveNext())
 			{
+				var sourceInstanceProperties = forwardedEnumerator.Current;
+
 				if (
 					IsAncestor(actualInstanceAlias, ancestors, sourceInstanceProperties.Value.Target)
 					|| (
@@ -1400,9 +1418,9 @@ void Propagate(DependencyObjectStore store)
 					}
 					else
 					{
-						foreach (var child in _childrenStores)
+						for (var i = 0; i < _childrenStores.Count; i++)
 						{
-							Propagate(child);
+							Propagate(_childrenStores[i]);
 						}
 					}
 				}
diff --git a/src/Uno.UI/UI/Xaml/FrameworkElement.Layout.netstd.cs b/src/Uno.UI/UI/Xaml/FrameworkElement.Layout.netstd.cs
@@ -50,23 +50,34 @@ internal sealed override void MeasureCore(Size availableSize)
 		{
 			if (_trace.IsEnabled)
 			{
-				var traceActivity = _trace.WriteEventActivity(
-					TraceProvider.FrameworkElement_MeasureStart,
-					TraceProvider.FrameworkElement_MeasureStop,
-					new object[] { GetType().Name, this.GetDependencyObjectId(), Name, availableSize.ToString() }
-				);
-
-				using (traceActivity)
+				/// <remarks>
+				/// This method contains or is called by a try/catch containing method and
+				/// can be significantly slower than other methods as a result on WebAssembly.
+				/// See https://github.com/dotnet/runtime/issues/56309
+				/// </remarks>
+				void MeasureCoreWithTrace(Size availableSize)
 				{
-					InnerMeasureCore(availableSize);
+					var traceActivity = _trace.WriteEventActivity(
+										TraceProvider.FrameworkElement_MeasureStart,
+										TraceProvider.FrameworkElement_MeasureStop,
+										new object[] { GetType().Name, this.GetDependencyObjectId(), Name, availableSize.ToString() }
+									);
+
+					using (traceActivity)
+					{
+						InnerMeasureCore(availableSize);
+					}
 				}
+
+				MeasureCoreWithTrace(availableSize);
 			}
 			else
 			{
 				// This method is split in two functions to avoid the dynCalls
 				// invocations generation for mono-wasm AOT inside of try/catch/finally blocks.
 				InnerMeasureCore(availableSize);
 			}
+
 		}
 
 		private void InnerMeasureCore(Size availableSize)
@@ -124,23 +135,29 @@ internal sealed override void ArrangeCore(Rect finalRect)
 		{
 			if (_trace.IsEnabled)
 			{
-				var traceActivity = _trace.WriteEventActivity(
-					TraceProvider.FrameworkElement_ArrangeStart,
-					TraceProvider.FrameworkElement_ArrangeStop,
-					new object[] { GetType().Name, this.GetDependencyObjectId(), Name, finalRect.ToString() }
-				);
-
-				using (traceActivity)
+				void ArrangeCoreWithTrace(Rect finalRect)
 				{
-					InnerArrangeCore(finalRect);
+					var traceActivity = _trace.WriteEventActivity(
+										TraceProvider.FrameworkElement_ArrangeStart,
+										TraceProvider.FrameworkElement_ArrangeStop,
+										new object[] { GetType().Name, this.GetDependencyObjectId(), Name, finalRect.ToString() }
+									);
+
+					using (traceActivity)
+					{
+						InnerArrangeCore(finalRect);
+					}
 				}
+
+				ArrangeCoreWithTrace(finalRect);
 			}
 			else
 			{
 				// This method is split in two functions to avoid the dynCalls
 				// invocations generation for mono-wasm AOT inside of try/catch/finally blocks.
 				InnerArrangeCore(finalRect);
 			}
+
 		}
 
 		private static bool IsLessThanAndNotCloseTo(double a, double b) => a < (b - SIZE_EPSILON);

Original file line number	Diff line number	Diff line change
`@@ -60,19 +60,30 @@ public static bool InvokeJSUnmarshalled(string functionIdentifier, IntPtr arg0)`
`60`	`60`	`{`
`61`	`61`	`if (_trace.IsEnabled)`
`62`	`62`	`{`
`63`		`- using (WritePropertyEventTrace(TraceProvider.UnmarshalledInvokedStart, TraceProvider.UnmarshalledInvokedEnd, functionIdentifier))`
`64`		`- {`
`65`		`- var ret = InnerInvokeJSUnmarshalled(functionIdentifier, arg0, out var exception);`
`66`		`-`
`67`		`- if(exception != null)`
`68`		`- {`
`69`		`- throw exception;`
`70`		`- }`
	`63`	`+ return InvokeJSUnmarshalledWithTrace(functionIdentifier, arg0);`
	`64`	`+ }`
	`65`	`+ else`
	`66`	`+ {`
	`67`	`+ var ret = InnerInvokeJSUnmarshalled(functionIdentifier, arg0, out var exception);`
`71`	`68`
`72`		`- return ret;`
	`69`	`+ if (exception != null)`
	`70`	`+ {`
	`71`	`+ throw exception;`
`73`	`72`	`}`
	`73`	`+`
	`74`	`+ return ret;`
`74`	`75`	`}`
`75`		`- else`
	`76`	`+ }`
	`77`	`+`
	`78`	`+ /// <remarks>`
	`79`	`+ /// This method contains or is called by a try/catch containing method and`
	`80`	`+ /// can be significantly slower than other methods as a result on WebAssembly.`
	`81`	`+ /// See https://github.com/dotnet/runtime/issues/56309`
	`82`	`+ /// </remarks>`
	`83`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`84`	`+ private static bool InvokeJSUnmarshalledWithTrace(string functionIdentifier, IntPtr arg0)`
	`85`	`+ {`
	`86`	`+ using (WritePropertyEventTrace(TraceProvider.UnmarshalledInvokedStart, TraceProvider.UnmarshalledInvokedEnd, functionIdentifier))`
`76`	`87`	`{`
`77`	`88`	`var ret = InnerInvokeJSUnmarshalled(functionIdentifier, arg0, out var exception);`
`78`	`89`
`@@ -93,17 +104,28 @@ internal static bool InvokeJSUnmarshalled(string functionIdentifier, IntPtr arg0`
`93`	`104`	`{`
`94`	`105`	`if (_trace.IsEnabled)`
`95`	`106`	`{`
`96`		`- using (WritePropertyEventTrace(TraceProvider.UnmarshalledInvokedStart, TraceProvider.UnmarshalledInvokedEnd, functionIdentifier))`
`97`		`- {`
`98`		`- return InnerInvokeJSUnmarshalled(functionIdentifier, arg0, out exception);`
`99`		`- }`
	`107`	`+ return InvokeJSUnmarshalledWithTrace(functionIdentifier, arg0, out exception);`
`100`	`108`	`}`
`101`	`109`	`else`
`102`	`110`	`{`
`103`	`111`	`return InnerInvokeJSUnmarshalled(functionIdentifier, arg0, out exception);`
`104`	`112`	`}`
`105`	`113`	`}`
`106`	`114`
	`115`	`+ /// <remarks>`
	`116`	`+ /// This method contains or is called by a try/catch containing method and`
	`117`	`+ /// can be significantly slower than other methods as a result on WebAssembly.`
	`118`	`+ /// See https://github.com/dotnet/runtime/issues/56309`
	`119`	`+ /// </remarks>`
	`120`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`121`	`+ private static bool InvokeJSUnmarshalledWithTrace(string functionIdentifier, IntPtr arg0, out Exception? exception)`
	`122`	`+ {`
	`123`	`+ using (WritePropertyEventTrace(TraceProvider.UnmarshalledInvokedStart, TraceProvider.UnmarshalledInvokedEnd, functionIdentifier))`
	`124`	`+ {`
	`125`	`+ return InnerInvokeJSUnmarshalled(functionIdentifier, arg0, out exception);`
	`126`	`+ }`
	`127`	`+ }`
	`128`	`+`
`107`	`129`	`private static bool InnerInvokeJSUnmarshalled(string functionIdentifier, IntPtr arg0, out Exception? exception)`
`108`	`130`	`{`
`109`	`131`	`exception = null;`
`@@ -135,17 +157,28 @@ public static bool InvokeJSUnmarshalled(string functionIdentifier, IntPtr arg0,`
`135`	`157`	`{`
`136`	`158`	`if (_trace.IsEnabled)`
`137`	`159`	`{`
`138`		`- using (WritePropertyEventTrace(TraceProvider.UnmarshalledInvokedStart, TraceProvider.UnmarshalledInvokedEnd, functionIdentifier))`
`139`		`- {`
`140`		`- return InnerInvokeJSUnmarshalled(functionIdentifier, arg0, arg1);`
`141`		`- }`
	`160`	`+ return InvokeJSUnmarshalledWithTrace(functionIdentifier, arg0, arg1);`
`142`	`161`	`}`
`143`	`162`	`else`
`144`	`163`	`{`
`145`	`164`	`return InnerInvokeJSUnmarshalled(functionIdentifier, arg0, arg1);`
`146`	`165`	`}`
`147`	`166`	`}`
`148`	`167`
	`168`	`+ /// <remarks>`
	`169`	`+ /// This method contains or is called by a try/catch containing method and`
	`170`	`+ /// can be significantly slower than other methods as a result on WebAssembly.`
	`171`	`+ /// See https://github.com/dotnet/runtime/issues/56309`
	`172`	`+ /// </remarks>`
	`173`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`174`	`+ private static bool InvokeJSUnmarshalledWithTrace(string functionIdentifier, IntPtr arg0, IntPtr arg1)`
	`175`	`+ {`
	`176`	`+ using (WritePropertyEventTrace(TraceProvider.UnmarshalledInvokedStart, TraceProvider.UnmarshalledInvokedEnd, functionIdentifier))`
	`177`	`+ {`
	`178`	`+ return InnerInvokeJSUnmarshalled(functionIdentifier, arg0, arg1);`
	`179`	`+ }`
	`180`	`+ }`
	`181`	`+`
`149`	`182`	`private static bool InnerInvokeJSUnmarshalled(string functionIdentifier, IntPtr arg0, IntPtr arg1)`
`150`	`183`	`{`
`151`	`184`	`var methodId = GetMethodId(functionIdentifier);`
`@@ -179,10 +212,7 @@ public static string InvokeJS(string str)`
`179`	`212`	`{`
`180`	`213`	`if (_trace.IsEnabled)`
`181`	`214`	`{`
`182`		`- using (WritePropertyEventTrace(TraceProvider.InvokeStart, TraceProvider.InvokeEnd, str))`
`183`		`- {`
`184`		`- return InnerInvokeJS(str);`
`185`		`- }`
	`215`	`+ return InvokeJSWithTrace(str);`
`186`	`216`	`}`
`187`	`217`	`else`
`188`	`218`	`{`
`@@ -203,6 +233,20 @@ public static string InvokeJS(string str)`
`203`	`233`	`}`
`204`	`234`	`}`
`205`	`235`
	`236`	`+ /// <remarks>`
	`237`	`+ /// This method contains or is called by a try/catch containing method and`
	`238`	`+ /// can be significantly slower than other methods as a result on WebAssembly.`
	`239`	`+ /// See https://github.com/dotnet/runtime/issues/56309`
	`240`	`+ /// </remarks>`
	`241`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`242`	`+ private static string InvokeJSWithTrace(string str)`
	`243`	`+ {`
	`244`	`+ using (WritePropertyEventTrace(TraceProvider.InvokeStart, TraceProvider.InvokeEnd, str))`
	`245`	`+ {`
	`246`	`+ return InnerInvokeJS(str);`
	`247`	`+ }`
	`248`	`+ }`
	`249`	`+`
`206`	`250`	`private static string InnerInvokeJS(String str)`
`207`	`251`	`{`
`208`	`252`	`if (_logger.Value.IsEnabled(LogLevel.Debug))`
Original file line number	Diff line number	Diff line change
`@@ -298,11 +298,21 @@ private void OnDataContextChanged(object? providedDataContext, object? actualDat`
`298`	`298`
`299`	`299`	`if (TryWriteDataContextChangedEventActivity() is { } trace)`
`300`	`300`	`{`
`301`		`- // "using" statements are costly under we https://github.com/dotnet/runtime/issues/50783`
`302`		`- using (trace)`
	`301`	`+ /// <remarks>`
	`302`	`+ /// This method contains or is called by a try/catch containing method and`
	`303`	`+ /// can be significantly slower than other methods as a result on WebAssembly.`
	`304`	`+ /// See https://github.com/dotnet/runtime/issues/56309`
	`305`	`+ /// </remarks>`
	`306`	`+ void ApplyWithTrace (object? actualDataContext, IDisposable trace)`
`303`	`307`	`{`
`304`		`- ApplyDataContext(actualDataContext);`
	`308`	`+ using (trace)`
	`309`	`+ {`
	`310`	`+ ApplyDataContext(actualDataContext);`
	`311`	`+ }`
`305`	`312`	`}`
	`313`	`+`
	`314`	`+ // "using" statements are costly under we https://github.com/dotnet/runtime/issues/50783`
	`315`	`+ ApplyWithTrace(actualDataContext, trace);`
`306`	`316`	`}`
`307`	`317`	`else`
`308`	`318`	`{`
Original file line number	Diff line number	Diff line change
`@@ -415,16 +415,25 @@ internal void SetValue(DependencyProperty property, object? value, DependencyPro`
`415`	`415`	`{`
`416`	`416`	`if (_trace.IsEnabled)`
`417`	`417`	`{`
`418`		`- using (WritePropertyEventTrace(TraceProvider.SetValueStart, TraceProvider.SetValueStop, property, precedence))`
	`418`	`+ /// <remarks>`
	`419`	`+ /// This method contains or is called by a try/catch containing method and`
	`420`	`+ /// can be significantly slower than other methods as a result on WebAssembly.`
	`421`	`+ /// See https://github.com/dotnet/runtime/issues/56309`
	`422`	`+ /// </remarks>`
	`423`	`+ void SetValueWithTrace(DependencyProperty property, object? value, DependencyPropertyValuePrecedences precedence, DependencyPropertyDetails? propertyDetails, bool isThemeBinding)`
`419`	`424`	`{`
`420`		`- InnerSetValue(property, value, precedence, propertyDetails, isThemeBinding);`
	`425`	`+ using (WritePropertyEventTrace(TraceProvider.SetValueStart, TraceProvider.SetValueStop, property, precedence))`
	`426`	`+ {`
	`427`	`+ InnerSetValue(property, value, precedence, propertyDetails, isThemeBinding);`
	`428`	`+ }`
`421`	`429`	`}`
	`430`	`+`
	`431`	`+ SetValueWithTrace(property, value, precedence, propertyDetails, isThemeBinding);`
`422`	`432`	`}`
`423`	`433`	`else`
`424`	`434`	`{`
`425`	`435`	`InnerSetValue(property, value, precedence, propertyDetails, isThemeBinding);`
`426`	`436`	`}`
`427`		`-`
`428`	`437`	`}`
`429`	`438`
`430`	`439`	`private void InnerSetValue(DependencyProperty property, object? value, DependencyPropertyValuePrecedences precedence, DependencyPropertyDetails? propertyDetails, bool isThemeBinding)`
`@@ -1000,8 +1009,12 @@ private void CleanupInheritedProperties()`
`1000`	`1009`
`1001`	`1010`	`if (ActualInstance != null)`
`1002`	`1011`	`{`
`1003`		`- foreach (var dp in _updatedProperties)`
	`1012`	`+ // This block is a manual enumeration to avoid the foreach pattern`
	`1013`	`+ // See https://github.com/dotnet/runtime/issues/56309 for details`
	`1014`	`+ var propertiesEnumerator = _updatedProperties.GetEnumerator();`
	`1015`	`+ while(propertiesEnumerator.MoveNext())`
`1004`	`1016`	`{`
	`1017`	`+ var dp = propertiesEnumerator.Current;`
`1005`	`1018`	`SetValue(dp, DependencyProperty.UnsetValue, DependencyPropertyValuePrecedences.Inheritance);`
`1006`	`1019`	`}`
`1007`	`1020`
`@@ -1367,8 +1380,13 @@ private void PropagateInheritedNonLocalProperties(DependencyObjectStore? childSt`
`1367`	`1380`	`// call to IsAncestor.`
`1368`	`1381`	`var actualInstanceAlias = ActualInstance;`
`1369`	`1382`
`1370`		`- foreach (var sourceInstanceProperties in _inheritedForwardedProperties)`
	`1383`	`+ // This block is a manual enumeration to avoid the foreach pattern`
	`1384`	`+ // See https://github.com/dotnet/runtime/issues/56309 for details`
	`1385`	`+ var forwardedEnumerator = _inheritedForwardedProperties.GetEnumerator();`
	`1386`	`+ while(forwardedEnumerator.MoveNext())`
`1371`	`1387`	`{`
	`1388`	`+ var sourceInstanceProperties = forwardedEnumerator.Current;`
	`1389`	`+`
`1372`	`1390`	`if (`
`1373`	`1391`	`IsAncestor(actualInstanceAlias, ancestors, sourceInstanceProperties.Value.Target)`
`1374`	`1392`	`\|\| (`
`@@ -1400,9 +1418,9 @@ void Propagate(DependencyObjectStore store)`
`1400`	`1418`	`}`
`1401`	`1419`	`else`
`1402`	`1420`	`{`
`1403`		`- foreach (var child in _childrenStores)`
	`1421`	`+ for (var i = 0; i < _childrenStores.Count; i++)`
`1404`	`1422`	`{`
`1405`		`- Propagate(child);`
	`1423`	`+ Propagate(_childrenStores[i]);`
`1406`	`1424`	`}`
`1407`	`1425`	`}`
`1408`	`1426`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,23 +50,34 @@ internal sealed override void MeasureCore(Size availableSize)`
`50`	`50`	`{`
`51`	`51`	`if (_trace.IsEnabled)`
`52`	`52`	`{`
`53`		`- var traceActivity = _trace.WriteEventActivity(`
`54`		`- TraceProvider.FrameworkElement_MeasureStart,`
`55`		`- TraceProvider.FrameworkElement_MeasureStop,`
`56`		`- new object[] { GetType().Name, this.GetDependencyObjectId(), Name, availableSize.ToString() }`
`57`		`- );`
`58`		`-`
`59`		`- using (traceActivity)`
	`53`	`+ /// <remarks>`
	`54`	`+ /// This method contains or is called by a try/catch containing method and`
	`55`	`+ /// can be significantly slower than other methods as a result on WebAssembly.`
	`56`	`+ /// See https://github.com/dotnet/runtime/issues/56309`
	`57`	`+ /// </remarks>`
	`58`	`+ void MeasureCoreWithTrace(Size availableSize)`
`60`	`59`	`{`
`61`		`- InnerMeasureCore(availableSize);`
	`60`	`+ var traceActivity = _trace.WriteEventActivity(`
	`61`	`+ TraceProvider.FrameworkElement_MeasureStart,`
	`62`	`+ TraceProvider.FrameworkElement_MeasureStop,`
	`63`	`+ new object[] { GetType().Name, this.GetDependencyObjectId(), Name, availableSize.ToString() }`
	`64`	`+ );`
	`65`	`+`
	`66`	`+ using (traceActivity)`
	`67`	`+ {`
	`68`	`+ InnerMeasureCore(availableSize);`
	`69`	`+ }`
`62`	`70`	`}`
	`71`	`+`
	`72`	`+ MeasureCoreWithTrace(availableSize);`
`63`	`73`	`}`
`64`	`74`	`else`
`65`	`75`	`{`
`66`	`76`	`// This method is split in two functions to avoid the dynCalls`
`67`	`77`	`// invocations generation for mono-wasm AOT inside of try/catch/finally blocks.`
`68`	`78`	`InnerMeasureCore(availableSize);`
`69`	`79`	`}`
	`80`	`+`
`70`	`81`	`}`
`71`	`82`
`72`	`83`	`private void InnerMeasureCore(Size availableSize)`
`@@ -124,23 +135,29 @@ internal sealed override void ArrangeCore(Rect finalRect)`
`124`	`135`	`{`
`125`	`136`	`if (_trace.IsEnabled)`
`126`	`137`	`{`
`127`		`- var traceActivity = _trace.WriteEventActivity(`
`128`		`- TraceProvider.FrameworkElement_ArrangeStart,`
`129`		`- TraceProvider.FrameworkElement_ArrangeStop,`
`130`		`- new object[] { GetType().Name, this.GetDependencyObjectId(), Name, finalRect.ToString() }`
`131`		`- );`
`132`		`-`
`133`		`- using (traceActivity)`
	`138`	`+ void ArrangeCoreWithTrace(Rect finalRect)`
`134`	`139`	`{`
`135`		`- InnerArrangeCore(finalRect);`
	`140`	`+ var traceActivity = _trace.WriteEventActivity(`
	`141`	`+ TraceProvider.FrameworkElement_ArrangeStart,`
	`142`	`+ TraceProvider.FrameworkElement_ArrangeStop,`
	`143`	`+ new object[] { GetType().Name, this.GetDependencyObjectId(), Name, finalRect.ToString() }`
	`144`	`+ );`
	`145`	`+`
	`146`	`+ using (traceActivity)`
	`147`	`+ {`
	`148`	`+ InnerArrangeCore(finalRect);`
	`149`	`+ }`
`136`	`150`	`}`
	`151`	`+`
	`152`	`+ ArrangeCoreWithTrace(finalRect);`
`137`	`153`	`}`
`138`	`154`	`else`
`139`	`155`	`{`
`140`	`156`	`// This method is split in two functions to avoid the dynCalls`
`141`	`157`	`// invocations generation for mono-wasm AOT inside of try/catch/finally blocks.`
`142`	`158`	`InnerArrangeCore(finalRect);`
`143`	`159`	`}`
	`160`	`+`
`144`	`161`	`}`
`145`	`162`
`146`	`163`	`private static bool IsLessThanAndNotCloseTo(double a, double b) => a < (b - SIZE_EPSILON);`