Fix #31939: CommandParameter TemplateBinding lost during reparenting (#32961)

When a Button inside a ControlTemplate has both Command and CommandParameter
with TemplateBinding, the async binding application path can cause Command
to be evaluated before CommandParameter resolves, resulting in CanExecute
being called with null parameter.

## Solution
Add a BindableProperty dependency mechanism via DependsOn() method. When
CommandProperty.DependsOn(CommandParameterProperty) is registered, the
CommandElement.GetCanExecute() forces the CommandParameter binding to apply
before calling CanExecute. This ensures the parameter value is available.

## Changes
- BindableProperty: Add Dependencies property and DependsOn() method
- BindableObject: Add ForceBindingApply() to force a binding to apply immediately
- CommandElement: Force dependency bindings to apply before calling CanExecute
- ButtonElement, CheckBox, SearchBar, MenuItem, RefreshView, TextCell: Register
  Command -> CommandParameter dependency
- All ICommandElement implementations: Pass CommandProperty to GetCanExecute()

## Testing
Added unit tests that verify:
1. Initial template binding works correctly
2. CommandParameter is preserved after reparenting (the bug scenario)

Author: StephaneDelcroix

src/Controls/src/Core/BindableObject.cs

@@ -432,6 +432,25 @@ internal bool GetIsBound(BindableProperty targetProperty)
 			return bpcontext != null && bpcontext.Bindings.Count > 0;
 		}
 
+		/// <summary>
+		/// Forces the binding for the specified property to apply immediately.
+		/// This is used when one property depends on another and needs the dependent
+		/// property's binding to resolve before proceeding.
+		/// See https://github.com/dotnet/maui/issues/31939
+		/// </summary>
+		internal void ForceBindingApply(BindableProperty targetProperty)
+		{
+			if (targetProperty == null)
+				throw new ArgumentNullException(nameof(targetProperty));
+
+			BindablePropertyContext bpcontext = GetContext(targetProperty);
+			if (bpcontext == null || bpcontext.Bindings.Count == 0)
+				return;
+
+			// Force the binding to apply now
+			ApplyBinding(bpcontext, fromBindingContextChanged: false);
+		}
+
 		internal virtual void OnRemoveDynamicResource(BindableProperty property)
 		{
 		}

src/Controls/src/Core/BindableProperty.cs

@@ -252,6 +252,21 @@ public sealed class BindableProperty
 
 		internal ValidateValueDelegate ValidateValue { get; private set; }
 
+		// Properties that this property depends on - when getting this property's value,
+		// if the dependency has a pending binding, return the default value instead.
+		// This is used to fix timing issues where one property binding resolves before another.
+		// See https://github.com/dotnet/maui/issues/31939
+		internal BindableProperty[] Dependencies { get; private set; }
+
+		/// <summary>
+		/// Registers a dependency on another BindableProperty. When this property's value is retrieved,
+		/// if the dependency has a binding that hasn't resolved yet (value is null), return null.
+		/// </summary>
+		internal void DependsOn(params BindableProperty[] dependencies)
+		{
+			Dependencies = dependencies;
+		}
+
 		/// <summary>Creates a new instance of the BindableProperty class.</summary>
 		/// <param name="propertyName">The name of the BindableProperty.</param>
 		/// <param name="returnType">The type of the property.</param>

src/Controls/src/Core/Button/Button.cs

@@ -465,7 +465,7 @@ void ICommandElement.CanExecuteChanged(object sender, EventArgs e) =>
 			RefreshIsEnabledProperty();
 
 		protected override bool IsEnabledCore =>
-			base.IsEnabledCore && CommandElement.GetCanExecute(this);
+			base.IsEnabledCore && CommandElement.GetCanExecute(this, CommandProperty);
 
 		bool _wasImageLoading;
 

src/Controls/src/Core/Button/ButtonElement.cs

@@ -10,16 +10,27 @@ static class ButtonElement
 		/// <summary>
 		/// The backing store for the <see cref="ICommandElement.Command" /> bindable property.
 		/// </summary>
-		public static readonly BindableProperty CommandProperty = BindableProperty.Create(
-			nameof(IButtonElement.Command), typeof(ICommand), typeof(IButtonElement), null,
-			propertyChanging: CommandElement.OnCommandChanging, propertyChanged: CommandElement.OnCommandChanged);
+		public static readonly BindableProperty CommandProperty;
 
 		/// <summary>
 		/// The backing store for the <see cref="ICommandElement.CommandParameter" /> bindable property.
 		/// </summary>
-		public static readonly BindableProperty CommandParameterProperty = BindableProperty.Create(
-			nameof(IButtonElement.CommandParameter), typeof(object), typeof(IButtonElement), null,
-			propertyChanged: CommandElement.OnCommandParameterChanged);
+		public static readonly BindableProperty CommandParameterProperty;
+
+		static ButtonElement()
+		{
+			CommandParameterProperty = BindableProperty.Create(
+				nameof(IButtonElement.CommandParameter), typeof(object), typeof(IButtonElement), null,
+				propertyChanged: CommandElement.OnCommandParameterChanged);
+
+			CommandProperty = BindableProperty.Create(
+				nameof(IButtonElement.Command), typeof(ICommand), typeof(IButtonElement), null,
+				propertyChanging: CommandElement.OnCommandChanging, propertyChanged: CommandElement.OnCommandChanged);
+
+			// Register dependency: Command depends on CommandParameter for CanExecute evaluation
+			// See https://github.com/dotnet/maui/issues/31939
+			CommandProperty.DependsOn(CommandParameterProperty);
+		}
 
 		/// <summary>
 		/// The string identifier for the pressed visual state of this control.

src/Controls/src/Core/Cells/TextCell.cs

@@ -11,19 +11,28 @@ namespace Microsoft.Maui.Controls
 	public class TextCell : Cell, ICommandElement
 	{
 		/// <summary>Bindable property for <see cref="Command"/>.</summary>
-		public static readonly BindableProperty CommandProperty =
-			BindableProperty.Create(nameof(Command), typeof(ICommand), typeof(TextCell),
-			propertyChanging: CommandElement.OnCommandChanging,
-			propertyChanged: CommandElement.OnCommandChanged);
+		public static readonly BindableProperty CommandProperty;
 
 		/// <summary>Bindable property for <see cref="CommandParameter"/>.</summary>
-		public static readonly BindableProperty CommandParameterProperty =
-			BindableProperty.Create(nameof(CommandParameter),
+		public static readonly BindableProperty CommandParameterProperty;
+
+		static TextCell()
+		{
+			CommandParameterProperty = BindableProperty.Create(nameof(CommandParameter),
 				typeof(object),
 				typeof(TextCell),
 				null,
 				propertyChanged: CommandElement.OnCommandParameterChanged);
 
+			CommandProperty = BindableProperty.Create(nameof(Command), typeof(ICommand), typeof(TextCell),
+				propertyChanging: CommandElement.OnCommandChanging,
+				propertyChanged: CommandElement.OnCommandChanged);
+
+			// Register dependency: Command depends on CommandParameter for CanExecute evaluation
+			// See https://github.com/dotnet/maui/issues/31939
+			CommandProperty.DependsOn(CommandParameterProperty);
+		}
+
 		/// <summary>Bindable property for <see cref="Text"/>.</summary>
 		public static readonly BindableProperty TextProperty = BindableProperty.Create(nameof(Text), typeof(string), typeof(TextCell), default(string));
 
@@ -95,10 +104,7 @@ protected internal override void OnTapped()
 
 		void ICommandElement.CanExecuteChanged(object sender, EventArgs eventArgs)
 		{
-			if (Command is null)
-				return;
-
-			IsEnabled = Command.CanExecute(CommandParameter);
+			IsEnabled = CommandElement.GetCanExecute(this, CommandProperty);
 		}
 
 		WeakCommandSubscription ICommandElement.CleanupTracker { get; set; }

src/Controls/src/Core/CheckBox/CheckBox.Mapper.cs

@@ -9,7 +9,13 @@ namespace Microsoft.Maui.Controls
 {
 	public partial class CheckBox
 	{
-		static CheckBox() => RemapForControls();
+		static CheckBox()
+		{
+			// Register dependency: Command depends on CommandParameter for CanExecute evaluation
+			// See https://github.com/dotnet/maui/issues/31939
+			CommandProperty.DependsOn(CommandParameterProperty);
+			RemapForControls();
+		}
 
 		private new static void RemapForControls()
 		{

src/Controls/src/Core/CheckBox/CheckBox.cs

@@ -145,7 +145,7 @@ void ICommandElement.CanExecuteChanged(object sender, EventArgs e) =>
 			RefreshIsEnabledProperty();
 
 		protected override bool IsEnabledCore =>
-			base.IsEnabledCore && CommandElement.GetCanExecute(this);
+			base.IsEnabledCore && CommandElement.GetCanExecute(this, CommandProperty);
 		public Paint Foreground => Color?.AsPaint();
 
 		bool ICheckBox.IsChecked

src/Controls/src/Core/CommandElement.cs

@@ -37,11 +37,23 @@ public static void OnCommandParameterChanged(BindableObject bo, object o, object
 			commandElement.CanExecuteChanged(bo, EventArgs.Empty);
 		}
 
-		public static bool GetCanExecute(ICommandElement commandElement)
+		public static bool GetCanExecute(ICommandElement commandElement, BindableProperty? commandProperty = null)
 		{
 			if (commandElement.Command == null)
 				return true;
 
+			// If there are dependencies (e.g., CommandParameter for Command), force their bindings
+			// to apply before evaluating CanExecute. This fixes timing issues where Command binding
+			// resolves before CommandParameter binding during reparenting.
+			// See https://github.com/dotnet/maui/issues/31939
+			if (commandProperty?.Dependencies is not null && commandElement is BindableObject bo)
+			{
+				foreach (var dependency in commandProperty.Dependencies)
+				{
+					bo.ForceBindingApply(dependency);
+				}
+			}
+
 			return commandElement.Command.CanExecute(commandElement.CommandParameter);
 		}
 	}

src/Controls/src/Core/ImageButton/ImageButton.cs

@@ -244,7 +244,7 @@ bool IImageElement.IsAnimationPlaying
 		bool IImageController.GetLoadAsAnimation() => false;
 
 		protected override bool IsEnabledCore =>
-			base.IsEnabledCore && CommandElement.GetCanExecute(this);
+			base.IsEnabledCore && CommandElement.GetCanExecute(this, CommandProperty);
 
 		void ICommandElement.CanExecuteChanged(object sender, EventArgs e) =>
 			RefreshIsEnabledProperty();

src/Controls/src/Core/Menu/MenuItem.cs

@@ -12,15 +12,26 @@ namespace Microsoft.Maui.Controls
 	public partial class MenuItem : BaseMenuItem, IMenuItemController, ICommandElement, IMenuElement, IPropertyPropagationController
 	{
 		/// <summary>Bindable property for <see cref="Command"/>.</summary>
-		public static readonly BindableProperty CommandProperty = BindableProperty.Create(
-			nameof(Command), typeof(ICommand), typeof(MenuItem), null,
-			propertyChanging: CommandElement.OnCommandChanging,
-			propertyChanged: CommandElement.OnCommandChanged);
+		public static readonly BindableProperty CommandProperty;
 
 		/// <summary>Bindable property for <see cref="CommandParameter"/>.</summary>
-		public static readonly BindableProperty CommandParameterProperty = BindableProperty.Create(
-			nameof(CommandParameter), typeof(object), typeof(MenuItem), null,
-			propertyChanged: CommandElement.OnCommandParameterChanged);
+		public static readonly BindableProperty CommandParameterProperty;
+
+		static MenuItem()
+		{
+			CommandParameterProperty = BindableProperty.Create(
+				nameof(CommandParameter), typeof(object), typeof(MenuItem), null,
+				propertyChanged: CommandElement.OnCommandParameterChanged);
+
+			CommandProperty = BindableProperty.Create(
+				nameof(Command), typeof(ICommand), typeof(MenuItem), null,
+				propertyChanging: CommandElement.OnCommandChanging,
+				propertyChanged: CommandElement.OnCommandChanged);
+
+			// Register dependency: Command depends on CommandParameter for CanExecute evaluation
+			// See https://github.com/dotnet/maui/issues/31939
+			CommandProperty.DependsOn(CommandParameterProperty);
+		}
 
 		/// <summary>Bindable property for <see cref="IsDestructive"/>.</summary>
 		public static readonly BindableProperty IsDestructiveProperty = BindableProperty.Create(nameof(IsDestructive), typeof(bool), typeof(MenuItem), false);
@@ -122,7 +133,7 @@ static object CoerceIsEnabledProperty(BindableObject bindable, object value)
 				return false;
 			}
 
-			var canExecute = CommandElement.GetCanExecute(menuItem);
+			var canExecute = CommandElement.GetCanExecute(menuItem, CommandProperty);
 			if (!canExecute)
 			{
 				return false;