perf: Apply various workarounds for dotnet/runtime issue #56309

These changes are required to reduce the interpreter performance hit.  The AOT compiler detects try/catch/finally containing methods and forces the interpreter, even if the try/catch is not in the execution path.

Inner methods are created to reduce the size of the interpreter-executed code, and return to AOT as soon as possible.

Author: jeromelaban

src/Uno.UI/DataBinding/BindingExpression.cs

@@ -16,6 +16,7 @@
 using Uno.UI.Converters;
 using Windows.UI.Xaml;
 using Windows.UI.Xaml.Data;
+using System.Runtime.CompilerServices;
 
 namespace Windows.UI.Xaml.Data
 {
@@ -194,17 +195,7 @@ public void UpdateSource(object value)
 
 				if (ParentBinding.XBindBack != null)
 				{
-					try
-					{
-						ParentBinding.XBindBack(DataContext, value);
-					}
-					catch (Exception exception)
-					{
-						if (this.Log().IsEnabled(Microsoft.Extensions.Logging.LogLevel.Error))
-						{
-							this.Log().Error($"Failed to set the source value for x:Bind path [{ParentBinding.Path}]", exception);
-						}
-					}
+					UpdateSourceOnXBindBack(value);
 				}
 				else
 				{
@@ -219,6 +210,27 @@ public void UpdateSource(object value)
 			}
 		}
 
+		/// <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 void UpdateSourceOnXBindBack(object value)
+		{
+			try
+			{
+				ParentBinding.XBindBack(DataContext, value);
+			}
+			catch (Exception exception)
+			{
+				if (this.Log().IsEnabled(Microsoft.Extensions.Logging.LogLevel.Error))
+				{
+					this.Log().Error($"Failed to set the source value for x:Bind path [{ParentBinding.Path}]", exception);
+				}
+			}
+		}
+
 		/// <summary>
 		/// Sets the source value in the data context
 		/// </summary>
@@ -511,39 +523,50 @@ void IValueChangedListener.OnValueChanged(object o)
 		{
 			if (ParentBinding.XBindSelector != null)
 			{
-				try
-				{
-					var canSetTarget = _updateSources?.None(s => s.ValueType == null) ?? true;
+				SetTargetValueForXBindSelector();
+			}
+			else
+			{
+				SetTargetValueSafe(o);
+			}
+		}
 
-					if (canSetTarget)
-					{
-						SetTargetValueSafe(ParentBinding.XBindSelector(DataContext));
-					}
-					else
-					{
-						// x:Bind failed bindings don't change the target value
-						// if no FallbackValue was specified.
-						ApplyFallbackValue(useTypeDefaultValue: false);
+		/// <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 void SetTargetValueForXBindSelector()
+		{
+			try
+			{
+				var canSetTarget = _updateSources?.None(s => s.ValueType == null) ?? true;
 
-						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");
-						}
-					}
+				if (canSetTarget)
+				{
+					SetTargetValueSafe(ParentBinding.XBindSelector(DataContext));
 				}
-				catch (Exception e)
+				else
 				{
-					ApplyFallbackValue();
+					// 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.Error))
+					if (this.Log().IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug))
 					{
-						this.Log().Error("Failed to apply binding to property [{0}] on [{1}] ({2})".InvariantCultureFormat(TargetPropertyDetails, _targetOwnerType, e.Message), e);
+						this.Log().Debug($"Binding path does not provide a value [{TargetPropertyDetails}] on [{_targetOwnerType}], using fallback value");
 					}
 				}
 			}
-			else
+			catch (Exception e)
 			{
-				SetTargetValueSafe(o);
+				ApplyFallbackValue();
+
+				if (this.Log().IsEnabled(Microsoft.Extensions.Logging.LogLevel.Error))
+				{
+					this.Log().Error("Failed to apply binding to property [{0}] on [{1}] ({2})".InvariantCultureFormat(TargetPropertyDetails, _targetOwnerType, e.Message), e);
+				}
 			}
 		}
 
@@ -572,29 +595,7 @@ private void SetTargetValueSafe(object v, bool useTargetNullValue)
 
 			try
 			{
-				if (v is UnsetValue)
-				{
-					ApplyFallbackValue();
-				}
-				else
-				{
-					_IsCurrentlyPushing = true;
-					// Get the source value and place it in the target property
-					var convertedValue = ConvertValue(v);
-
-					if (convertedValue == DependencyProperty.UnsetValue)
-					{
-						ApplyFallbackValue();
-					}
-					else if (useTargetNullValue && convertedValue == null && ParentBinding.TargetNullValue != null)
-					{
-						SetTargetValue(ConvertValue(ParentBinding.TargetNullValue));
-					}
-					else
-					{
-						SetTargetValue(convertedValue);
-					}
-				}
+				InnerSetTargetValueSafe(v, useTargetNullValue);
 			}
 			catch (Exception e)
 			{
@@ -613,6 +614,39 @@ private void SetTargetValueSafe(object v, bool useTargetNullValue)
 			}
 		}
 
+		/// <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 void InnerSetTargetValueSafe(object v, bool useTargetNullValue)
+		{
+			if (v is UnsetValue)
+			{
+				ApplyFallbackValue();
+			}
+			else
+			{
+				_IsCurrentlyPushing = true;
+				// Get the source value and place it in the target property
+				var convertedValue = ConvertValue(v);
+
+				if (convertedValue == DependencyProperty.UnsetValue)
+				{
+					ApplyFallbackValue();
+				}
+				else if (useTargetNullValue && convertedValue == null && ParentBinding.TargetNullValue != null)
+				{
+					SetTargetValue(ConvertValue(ParentBinding.TargetNullValue));
+				}
+				else
+				{
+					SetTargetValue(convertedValue);
+				}
+			}
+		}
+
 		private string GetCurrentCulture() => CultureInfo.CurrentCulture.ToString();
 
 

src/Uno.UI/DataBinding/BindingPropertyHelper.cs

@@ -18,6 +18,7 @@
 using Microsoft.Extensions.Logging;
 using Windows.UI.Xaml.Data;
 using System.Dynamic;
+using System.Runtime.CompilerServices;
 
 namespace Uno.UI.DataBinding
 {
@@ -1066,24 +1067,37 @@ private static DependencyProperty FindDependencyProperty(Type ownerType, string
 					}
 					else if (t != typeof(object))
 					{
-						try
-						{
-							value = Conversion.To(value, t, CultureInfo.CurrentCulture);
-						}
-						catch (Exception)
-						{
-							// This is a temporary fallback solution.
-							// The problem is that we don't actually know which culture we must use in advance.
-							// Values can come from the xaml (invariant culture) or from a two way binding (current culture).
-							// The real solution would be to pass a culture or source when setting a value in a Dependency Property.
-							value = Conversion.To(value, t, CultureInfo.InvariantCulture);
-						}
+						value = ConvertWithConvertionExtension(value, t);
 					}
 				}
 			}
 			return value;
 		}
 
+		/// <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 object ConvertWithConvertionExtension(object? value, Type? t)
+		{
+			try
+			{
+				value = Conversion.To(value, t, CultureInfo.CurrentCulture);
+			}
+			catch (Exception)
+			{
+				// This is a temporary fallback solution.
+				// The problem is that we don't actually know which culture we must use in advance.
+				// Values can come from the xaml (invariant culture) or from a two way binding (current culture).
+				// The real solution would be to pass a culture or source when setting a value in a Dependency Property.
+				value = Conversion.To(value, t, CultureInfo.InvariantCulture);
+			}
+
+			return value;
+		}
+
 		private static object UnsetValueGetter(object unused)
 			=> DependencyProperty.UnsetValue;