Skip useless handler mappings calls while connecting (#27259)

* Skip useless initial handler mappings calls

* Apply suggestions from code review, fixes check on Maximum*

* Windows: automation properties are extremely costly

* Fix broken UI tests

* Workaround Windows broken tests

---------

Co-authored-by: MartyIX <203266+MartyIX@users.noreply.github.com>

Author: 2 people

src/Controls/src/Core/Element/Element.Windows.cs

@@ -9,6 +9,9 @@ public partial class Element
 	{
 		public static void MapAutomationPropertiesIsInAccessibleTree(IElementHandler handler, Element element)
 		{
+			if (handler.IsConnectingHandler() && element.GetValue(AutomationProperties.IsInAccessibleTreeProperty) is null)
+				return;
+
 			Platform.AccessibilityExtensions.SetAutomationPropertiesAccessibilityView(
 				handler.PlatformView as Microsoft.UI.Xaml.FrameworkElement, element);
 		}

src/Controls/src/Core/Label/Label.Mapper.cs

@@ -21,7 +21,7 @@ public partial class Label
 
 			// these are really a single property
 			LabelHandler.Mapper.ReplaceMapping<Label, ILabelHandler>(nameof(Text), MapText);
-			LabelHandler.Mapper.ReplaceMapping<Label, ILabelHandler>(nameof(FormattedText), MapText);
+			LabelHandler.Mapper.ReplaceMapping<Label, ILabelHandler>(nameof(FormattedText), MapFormattedText);
 
 			LabelHandler.Mapper.ReplaceMapping<Label, ILabelHandler>(nameof(LineBreakMode), MapLineBreakMode);
 			LabelHandler.Mapper.ReplaceMapping<Label, ILabelHandler>(nameof(MaxLines), MapMaxLines);
@@ -54,8 +54,17 @@ public static void MapTextType(ILabelHandler handler, Label label) =>
 			MapTextOrFormattedText(handler, label);
 		static void MapTextTransform(ILabelHandler handler, Label label) =>
 			MapTextOrFormattedText(handler, label);
+		static void MapFormattedText(ILabelHandler handler, Label label)
+		{
+			if (label.IsConnectingHandler()) return;
+
+			MapText(handler, label);
+		}
+
 		static void MapTextOrFormattedText(ILabelHandler handler, Label label)
 		{
+			if (label.IsConnectingHandler()) return;
+
 			if (label.HasFormattedTextSpans)
 				handler.UpdateValue(nameof(FormattedText));
 			else

src/Core/src/Core/Extensions/InternalElementExtensions.cs

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Microsoft.Maui
+{
+	internal static class InternalElementExtensions
+	{
+		/// <summary>
+		/// The handler is connecting for the first time to the element and mapping all properties.
+		/// </summary>
+		/// <param name="element"></param>
+		/// <returns></returns>
+		internal static bool IsMappingProperties(this IElement element) =>
+			(element.Handler as IElementHandlerStateExhibitor)?.State.HasFlag(ElementHandlerState.MappingProperties) ?? false;
+
+		/// <summary>
+		/// Indicates whether the handler is connecting for the first time to the element and mapping all properties.
+		/// </summary>
+		/// <param name="element"></param>
+		/// <returns></returns>
+		internal static bool IsConnectingHandler(this IElement element) =>
+			(element.Handler as IElementHandlerStateExhibitor)?.State.HasFlag(ElementHandlerState.Connecting) ?? false;
+
+		/// <summary>
+		/// Indicates whether the connected handler is now connecting to a new element and updating properties.
+		/// </summary>
+		/// <param name="element"></param>
+		/// <returns></returns>
+		internal static bool IsReconnectingHandler(this IElement element) =>
+			(element.Handler as IElementHandlerStateExhibitor)?.State.HasFlag(ElementHandlerState.Reconnecting) ?? false;
+	}
+}

src/Core/src/Handlers/Border/BorderHandler.cs

@@ -11,6 +11,7 @@
 using PlatformView = System.Object;
 #endif
 
+using System.Runtime.CompilerServices;
 using Microsoft.Maui.Graphics;
 
 namespace Microsoft.Maui.Handlers
@@ -86,13 +87,29 @@ public static void MapBackground(IBorderHandler handler, IBorderView border)
 			((PlatformView?)handler.PlatformView)?.UpdateBackground(border);
 		}
 
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static bool ShouldSkipStrokeMappings(IBorderHandler handler) {
+#if __IOS__ || MACCATALYST || ANDROID
+			// During the initial connection, the `MapBackground` takes care of updating the stroke properties
+			// so we can skip the stroke mappings to avoid repetitive and useless updates.
+			return handler.IsConnectingHandler();
+#else
+			return false;
+#endif
+		}
+
 		/// <summary>
 		/// Maps the abstract <see cref="IBorderStroke.Shape"/> property to the platform-specific implementations.
 		/// </summary>
 		/// <param name="handler">The associated handler.</param>
 		/// <param name="border">The associated <see cref="IBorderView"/> instance.</param>
 		public static void MapStrokeShape(IBorderHandler handler, IBorderView border)
 		{
+			if (ShouldSkipStrokeMappings(handler))
+			{
+				return;
+			}
+
 			((PlatformView?)handler.PlatformView)?.UpdateStrokeShape(border);
 			MapBackground(handler, border);
 		}
@@ -104,6 +121,11 @@ public static void MapStrokeShape(IBorderHandler handler, IBorderView border)
 		/// <param name="border">The associated <see cref="IBorderView"/> instance.</param>
 		public static void MapStroke(IBorderHandler handler, IBorderView border)
 		{
+			if (ShouldSkipStrokeMappings(handler))
+			{
+				return;
+			}
+
 			((PlatformView?)handler.PlatformView)?.UpdateStroke(border);
 			MapBackground(handler, border);
 		}
@@ -115,6 +137,11 @@ public static void MapStroke(IBorderHandler handler, IBorderView border)
 		/// <param name="border">The associated <see cref="IBorderView"/> instance.</param>
 		public static void MapStrokeThickness(IBorderHandler handler, IBorderView border)
 		{
+			if (ShouldSkipStrokeMappings(handler))
+			{
+				return;
+			}
+
 			((PlatformView?)handler.PlatformView)?.UpdateStrokeThickness(border);
 			MapBackground(handler, border);
 		}
@@ -126,6 +153,11 @@ public static void MapStrokeThickness(IBorderHandler handler, IBorderView border
 		/// <param name="border">The associated <see cref="IBorderView"/> instance.</param>
 		public static void MapStrokeLineCap(IBorderHandler handler, IBorderView border)
 		{
+			if (ShouldSkipStrokeMappings(handler))
+			{
+				return;
+			}
+
 			((PlatformView?)handler.PlatformView)?.UpdateStrokeLineCap(border);
 		}
 
@@ -136,6 +168,11 @@ public static void MapStrokeLineCap(IBorderHandler handler, IBorderView border)
 		/// <param name="border">The associated <see cref="IBorderView"/> instance.</param>
 		public static void MapStrokeLineJoin(IBorderHandler handler, IBorderView border)
 		{
+			if (ShouldSkipStrokeMappings(handler))
+			{
+				return;
+			}
+
 			((PlatformView?)handler.PlatformView)?.UpdateStrokeLineJoin(border);
 		}
 
@@ -146,6 +183,11 @@ public static void MapStrokeLineJoin(IBorderHandler handler, IBorderView border)
 		/// <param name="border">The associated <see cref="IBorderView"/> instance.</param>
 		public static void MapStrokeDashPattern(IBorderHandler handler, IBorderView border)
 		{
+			if (ShouldSkipStrokeMappings(handler))
+			{
+				return;
+			}
+
 			((PlatformView?)handler.PlatformView)?.UpdateStrokeDashPattern(border);
 		}
 
@@ -156,6 +198,11 @@ public static void MapStrokeDashPattern(IBorderHandler handler, IBorderView bord
 		/// <param name="border">The associated <see cref="IBorderView"/> instance.</param>
 		public static void MapStrokeDashOffset(IBorderHandler handler, IBorderView border)
 		{
+			if (ShouldSkipStrokeMappings(handler))
+			{
+				return;
+			}
+
 			((PlatformView?)handler.PlatformView)?.UpdateStrokeDashOffset(border);
 		}
 
@@ -166,6 +213,11 @@ public static void MapStrokeDashOffset(IBorderHandler handler, IBorderView borde
 		/// <param name="border">The associated <see cref="IBorderView"/> instance.</param>
 		public static void MapStrokeMiterLimit(IBorderHandler handler, IBorderView border)
 		{
+			if (ShouldSkipStrokeMappings(handler))
+			{
+				return;
+			}
+
 			((PlatformView?)handler.PlatformView)?.UpdateStrokeMiterLimit(border);
 		}
 

src/Core/src/Handlers/Element/ElementHandler.cs

@@ -2,7 +2,7 @@
 
 namespace Microsoft.Maui.Handlers
 {
-	public abstract partial class ElementHandler : IElementHandler
+	public abstract partial class ElementHandler : IElementHandler, IElementHandlerStateExhibitor
 	{
 		public static IPropertyMapper<IElement, IElementHandler> ElementMapper = new PropertyMapper<IElement, IElementHandler>()
 		{
@@ -15,6 +15,9 @@ public abstract partial class ElementHandler : IElementHandler
 		internal readonly IPropertyMapper _defaultMapper;
 		internal readonly CommandMapper? _commandMapper;
 		internal IPropertyMapper _mapper;
+		ElementHandlerState _handlerState;
+
+		ElementHandlerState IElementHandlerStateExhibitor.State => _handlerState;
 
 		protected ElementHandler(IPropertyMapper mapper, CommandMapper? commandMapper = null)
 		{
@@ -40,24 +43,38 @@ public virtual void SetVirtualView(IElement view)
 			_ = view ?? throw new ArgumentNullException(nameof(view));
 
 			if (VirtualView == view)
+			{
 				return;
+			}
 
 			var oldVirtualView = VirtualView;
 
 			bool setupPlatformView = oldVirtualView == null;
 
 			VirtualView = view;
-			PlatformView ??= CreatePlatformElement();
+			if (PlatformView is null)
+			{
+				_handlerState = ElementHandlerState.Connecting;
+				PlatformView = CreatePlatformElement();
+			}
+			else
+			{
+				_handlerState = ElementHandlerState.Reconnecting;
+			}
 
 			if (VirtualView.Handler != this)
+			{
 				VirtualView.Handler = this;
+			}
 
 			// We set the previous virtual view to null after setting it on the incoming virtual view.
 			// This makes it easier for the incoming virtual view to have influence
 			// on how the exchange of handlers happens.
 			// We will just set the handler to null ourselves as a last resort cleanup
 			if (oldVirtualView?.Handler != null)
+			{
 				oldVirtualView.Handler = null;
+			}
 
 			if (setupPlatformView)
 			{
@@ -77,6 +94,8 @@ public virtual void SetVirtualView(IElement view)
 			}
 
 			_mapper.UpdateProperties(this, VirtualView);
+
+			_handlerState = ElementHandlerState.Connected;
 		}
 
 		public virtual void UpdateValue(string property)
@@ -129,6 +148,8 @@ void IElementHandler.DisconnectHandler()
 				PlatformView = null;
 				DisconnectHandler(oldPlatformView);
 			}
+
+			_handlerState = ElementHandlerState.Disconnected;
 		}
 	}
 }

src/Core/src/Handlers/ElementHandlerState.cs

@@ -0,0 +1,32 @@
+using System;
+
+namespace Microsoft.Maui
+{
+	/// <summary>
+	/// Exposes the state of an element handler.
+	/// </summary>
+	[Flags]
+	internal enum ElementHandlerState : byte
+	{
+		/// <summary>
+		/// The handler is not connected to an element.
+		/// </summary>
+		Disconnected = 0x0,
+		/// <summary>
+		/// The handler is mapping all properties to the element.
+		/// </summary>
+		MappingProperties = 0x1,
+		/// <summary>
+		/// The handler is connecting for the first time to the element and mapping all properties.
+		/// </summary>
+		Connecting = MappingProperties | 0x2,
+		/// <summary>
+		/// The connected handler is now connecting to a new element and updating properties.
+		/// </summary>
+		Reconnecting = MappingProperties | 0x4,
+		/// <summary>
+		/// The handler is connected to an element.
+		/// </summary>
+		Connected = 0x8
+	}
+}

src/Core/src/Handlers/IElementHandlerStateExhibitor.cs

@@ -0,0 +1,16 @@
+namespace Microsoft.Maui
+{
+	/// <summary>
+	/// Exposes the state of an element handler.
+	/// </summary>
+	/// <remarks>
+	/// To be migrated to a public API.
+	/// </remarks>
+	internal interface IElementHandlerStateExhibitor
+	{
+		/// <summary>  
+		/// Gets the state of the element handler.  
+		/// </summary>  
+		ElementHandlerState State { get; }
+	}
+}

src/Core/src/Handlers/InternalElementHandlerExtensions.cs

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Microsoft.Maui
+{
+	internal static class InternalElementHandlerExtensions
+	{
+		/// <summary>
+		/// The handler is connecting for the first time to the element and mapping all properties.
+		/// </summary>
+		/// <param name="handler"></param>
+		/// <returns></returns>
+		internal static bool IsMappingProperties(this IElementHandler handler) =>
+			(handler as IElementHandlerStateExhibitor)?.State.HasFlag(ElementHandlerState.MappingProperties) ?? false;
+
+		/// <summary>
+		/// Indicates whether the handler is connecting for the first time to the element and mapping all properties.
+		/// </summary>
+		/// <param name="handler"></param>
+		/// <returns></returns>
+		internal static bool IsConnectingHandler(this IElementHandler handler) =>
+			(handler as IElementHandlerStateExhibitor)?.State.HasFlag(ElementHandlerState.Connecting) ?? false;
+
+		/// <summary>
+		/// Indicates whether the connected handler is now connecting to a new element and updating properties.
+		/// </summary>
+		/// <param name="handler"></param>
+		/// <returns></returns>
+		internal static bool IsReconnectingHandler(this IElementHandler handler) =>
+			(handler as IElementHandlerStateExhibitor)?.State.HasFlag(ElementHandlerState.Reconnecting) ?? false;
+	}
+}