perf: Reduce delegates use in BindingPath property changed

This change significantly reduces the number of delegates created during the propagation of property changes. This reduces the memory footprint, and improves the invocation performance under Wasm MixedAOT.

Author: jeromelaban

src/Uno.UI/DataBinding/BindingPath.cs

@@ -22,7 +22,7 @@ namespace Uno.UI.DataBinding
 	[DebuggerDisplay("Path={_path} DataContext={_dataContext}")]
 	internal class BindingPath : IDisposable, IValueChangedListener
 	{
-		private static List<PropertyChangedRegistrationHandler> _propertyChangedHandlers = new List<PropertyChangedRegistrationHandler>();
+		private static List<IPropertyChangedRegistrationHandler> _propertyChangedHandlers = new List<IPropertyChangedRegistrationHandler>(2);
 		private readonly string _path;
 
 		private BindingItem? _chain;
@@ -31,13 +31,40 @@ internal class BindingPath : IDisposable, IValueChangedListener
 		private bool _disposed;
 
 		/// <summary>
-		/// Defines a delegate that will create a registration on the specified <paramref name="dataContext"/>> for the specified <paramref name="propertyName"/>.
+		/// Defines a interface that will allow for the creation of a registration on the specified dataContext
+		/// for the specified propertyName.
 		/// </summary>
-		/// <param name="dataContext">The datacontext to use</param>
-		/// <param name="propertyName">The property in the datacontext</param>
-		/// <param name="onNewValue">The action to execute when a new value is raised</param>
-		/// <returns>A disposable that will cleanup resources.</returns>
-		public delegate IDisposable? PropertyChangedRegistrationHandler(ManagedWeakReference dataContext, string propertyName, Action onNewValue);
+		public interface IPropertyChangedRegistrationHandler
+		{
+			/// <summary>
+			/// Registere a new <see cref="IPropertyChangedValueHandler"/> for the specified property
+			/// </summary>
+			/// <param name="dataContext">The datacontext to use</param>
+			/// <param name="propertyName">The property in the datacontext</param>
+			/// <param name="onNewValue">The action to execute when a new value is raised</param>
+			/// <returns>A disposable that will cleanup resources.</returns>
+			IDisposable? Register(ManagedWeakReference dataContext, string propertyName, IPropertyChangedValueHandler onNewValue);
+		}
+
+		/// <summary>
+		/// PropertyChanged value handler.
+		/// </summary>
+		/// <remarks>
+		/// This is an interface to avoid the use of delegates, and delegates type conversion as
+		/// there are two available signatures. (<see cref="Action"/> and <see cref="DependencyPropertyChangedCallback"/>)
+		/// </remarks>
+		public interface IPropertyChangedValueHandler
+		{
+			/// <summary>
+			/// Process a property changed using the <see cref="DependencyPropertyChangedCallback"/> signature.
+			/// </summary>
+			void NewValue(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs args);
+
+			/// <summary>
+			/// Processa a property changed using <see cref="Action"/>-like signature (e.g. for <see cref="BindingItem"/>)
+			/// </summary>
+			void NewValue();
+		}
 
 		/// <summary>
 		/// Provides the new values for the current binding.
@@ -49,7 +76,7 @@ internal class BindingPath : IDisposable, IValueChangedListener
 
 		static BindingPath()
 		{
-			RegisterPropertyChangedRegistrationHandler(SubscribeToNotifyPropertyChanged);
+			RegisterPropertyChangedRegistrationHandler(new BindingPathPropertyChangedRegistrationHandler());
 		}
 
 		/// <summary>
@@ -122,7 +149,7 @@ internal void CloneShareableObjectsInPath()
 		/// <remarks>This method exists to provide layer separation,
 		/// when BindingPath is in the presentation layer, and DependencyProperty is in the (some) Views layer.
 		/// </remarks>
-		public static void RegisterPropertyChangedRegistrationHandler(PropertyChangedRegistrationHandler handler)
+		public static void RegisterPropertyChangedRegistrationHandler(IPropertyChangedRegistrationHandler handler)
 		{
 			_propertyChangedHandlers.Add(handler);
 		}
@@ -279,6 +306,15 @@ protected virtual void Dispose(bool disposing)
 			}
 		}
 
+		/// <summary>
+		/// Property changed registration handler for BindingPath.
+		/// </summary>
+		private class BindingPathPropertyChangedRegistrationHandler : IPropertyChangedRegistrationHandler
+		{
+			public IDisposable? Register(ManagedWeakReference dataContext, string propertyName, IPropertyChangedValueHandler onNewValue)
+				=> SubscribeToNotifyPropertyChanged(dataContext, propertyName, onNewValue);
+		}
+
 		#region Miscs helpers
 		/// <summary>
 		/// Parse the given string path in parts and create the linked list of binding items in head and tail
@@ -374,7 +410,7 @@ private static void TryPrependItem(
 		/// <summary>
 		/// Subscribes for updates to the INotifyPropertyChanged interface.
 		/// </summary>
-		private static IDisposable? SubscribeToNotifyPropertyChanged(ManagedWeakReference dataContextReference, string propertyName, Action newValueAction)
+		private static IDisposable? SubscribeToNotifyPropertyChanged(ManagedWeakReference dataContextReference, string propertyName, IPropertyChangedValueHandler propertyChangedValueHandler)
 		{
 			// Attach to the Notify property changed events
 			var notify = dataContextReference.Target as System.ComponentModel.INotifyPropertyChanged;
@@ -386,7 +422,7 @@ private static void TryPrependItem(
 					propertyName = "Item" + propertyName;
 				}
 
-				var newValueActionWeak = Uno.UI.DataBinding.WeakReferencePool.RentWeakReference(null, newValueAction);
+				var newValueActionWeak = Uno.UI.DataBinding.WeakReferencePool.RentWeakReference(null, propertyChangedValueHandler);
 
 				System.ComponentModel.PropertyChangedEventHandler handler = (s, args) =>
 				{
@@ -397,9 +433,10 @@ private static void TryPrependItem(
 							typeof(BindingPath).Log().Debug($"Property changed for {propertyName} on [{dataContextReference.Target?.GetType()}]");
 						}
 
-						if (!newValueActionWeak.IsDisposed)
+						if (!newValueActionWeak.IsDisposed
+						&& newValueActionWeak.Target is IPropertyChangedValueHandler handler)
 						{
-							(newValueActionWeak.Target as Action)?.Invoke();
+							handler.NewValue();
 						}
 					}
 				};
@@ -808,22 +845,14 @@ private IDisposable SubscribeToPropertyChanged()
 				for (var i = 0; i < _propertyChangedHandlers.Count; i++)
 				{
 					var handler = _propertyChangedHandlers[i];
-					object? previousValue = default;
 
-					Action? updateProperty = () =>
-					{
-						var newValue = GetSourceValue();
-
-						OnPropertyChanged(previousValue, newValue, shouldRaiseValueChanged: true);
-
-						previousValue = newValue;
-					};
+					var valueHandler = new PropertyChangedValueHandler(this);
 
-					var handlerDisposable = handler(_dataContextWeakStorage!, PropertyName, updateProperty);
+					var handlerDisposable = handler.Register(_dataContextWeakStorage!, PropertyName, valueHandler);
 
 					if (handlerDisposable != null)
 					{
-						previousValue = GetSourceValue();
+						valueHandler.PreviousValue = GetSourceValue();
 
 						// We need to keep the reference to the updatePropertyHandler
 						// in this disposable. The reference is attached to the source's
@@ -833,7 +862,9 @@ private IDisposable SubscribeToPropertyChanged()
 						// weak with regards to the delegates that are provided.
 						disposables.Add(() =>
 						{
-							updateProperty = null;
+							var previousValue = valueHandler.PreviousValue;
+
+							valueHandler = null;
 							handlerDisposable.Dispose();
 							OnPropertyChanged(previousValue, DependencyProperty.UnsetValue, shouldRaiseValueChanged: false);
 						});
@@ -848,6 +879,43 @@ public void Dispose()
 				_disposed = true;
 				_propertyChanged.Dispose();
 			}
+
+			/// <summary>
+			/// Property changed value handler, used to avoid creating a delegate for processing
+			/// </summary>
+			/// <remarks>
+			/// This class is primarily used to avoid the costs associated with creating, storing and invoking delegates,
+			/// particularly on WebAssembly as of .NET 6 where invoking a delegate requires a context switch from AOT
+			/// to the interpreter.
+			/// </remarks>
+			private class PropertyChangedValueHandler : IPropertyChangedValueHandler, IWeakReferenceProvider
+			{
+				private readonly BindingItem _owner;
+				private readonly ManagedWeakReference _self;
+
+				public PropertyChangedValueHandler(BindingItem owner)
+				{
+					_owner = owner;
+					_self = WeakReferencePool.RentSelfWeakReference(this);
+				}
+
+				public object? PreviousValue { get; set; }
+
+				public ManagedWeakReference WeakReference
+					=> _self;
+
+				public void NewValue()
+				{
+					var newValue = _owner.GetSourceValue();
+
+					_owner.OnPropertyChanged(PreviousValue, newValue, shouldRaiseValueChanged: true);
+
+					PreviousValue = newValue;
+				}
+
+				public void NewValue(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs args)
+					=> NewValue();
+			}
 		}
 	}
 }

src/Uno.UI/UI/Xaml/DependencyObjectStore.Binder.cs

@@ -191,7 +191,7 @@ private string GetOwnerDebugString()
 		static void InitializeStaticBinder()
 		{
 			// Register the ability for the BindingPath to subscribe to dependency property changes.
-			BindingPath.RegisterPropertyChangedRegistrationHandler(SubscribeToDependencyPropertyChanged);
+			BindingPath.RegisterPropertyChangedRegistrationHandler(new BindingPathPropertyChangedRegistrationHandler());
 		}
 
 		internal DependencyProperty DataContextProperty => _dataContextProperty!;
@@ -532,7 +532,7 @@ internal void SetBindingValue(DependencyPropertyDetails propertyDetails, object
 		/// <param name="newValueAction">The action to execute when a new value is raised</param>
 		/// <param name="disposeAction">The action to execute when the listener wants to dispose the subscription</param>
 		/// <returns></returns>
-		private static IDisposable? SubscribeToDependencyPropertyChanged(ManagedWeakReference dataContextReference, string propertyName, Action newValueAction)
+		private static IDisposable? SubscribeToDependencyPropertyChanged(ManagedWeakReference dataContextReference, string propertyName, BindingPath.IPropertyChangedValueHandler newValueAction)
 		{
 			var dependencyObject = dataContextReference.Target as DependencyObject;
 
@@ -542,10 +542,8 @@ internal void SetBindingValue(DependencyPropertyDetails propertyDetails, object
 
 				if (dp != null)
 				{
-					Windows.UI.Xaml.PropertyChangedCallback handler = (s, e) => newValueAction();
-
 					return Windows.UI.Xaml.DependencyObjectExtensions
-						.RegisterDisposablePropertyChangedCallback(dependencyObject, dp, handler);
+						.RegisterDisposablePropertyChangedCallback(dependencyObject, dp, newValueAction.NewValue);
 				}
 				else
 				{
@@ -657,6 +655,15 @@ public BindingExpression GetBindingExpression(DependencyProperty dependencyPrope
 
 		public Windows.UI.Xaml.Data.Binding? GetBinding(DependencyProperty dependencyProperty)
 			=> GetBindingExpression(dependencyProperty)?.ParentBinding;
+
+		/// <summary>
+		/// BindingPath Registration handler for DependencyProperty instances
+		/// </summary>
+		private class BindingPathPropertyChangedRegistrationHandler : BindingPath.IPropertyChangedRegistrationHandler
+		{
+			public IDisposable? Register(ManagedWeakReference dataContext, string propertyName, BindingPath.IPropertyChangedValueHandler onNewValue)
+				=> SubscribeToDependencyPropertyChanged(dataContext, propertyName, onNewValue);
+		}
 	}
 }