Fix Slider and Stepper property order independence

This change ensures that the Value property of Slider and Stepper controls
is correctly preserved regardless of the order in which Minimum, Maximum,
and Value properties are set (either programmatically or via XAML bindings).

The fix introduces:
- _requestedValue: stores the user's intended value before clamping
- _userSetValue: tracks if the user explicitly set Value
- _isRecoercing: prevents _requestedValue corruption during recoercion
- RecoerceValue(): restores _requestedValue when range expands

When Min/Max changes, if the user explicitly set Value, the original
requested value is restored (clamped to the new range). This allows
Value to 'spring back' when the range expands to include it.

Fixes dotnet#32903
Fixes dotnet#14472
Fixes dotnet#18910
Fixes dotnet#12243

Author: StephaneDelcroix

src/Controls/src/Core/Slider/Slider.cs

@@ -10,33 +10,64 @@ namespace Microsoft.Maui.Controls
 	[DebuggerDisplay("{GetDebuggerDisplay(), nq}")]
 	public partial class Slider : View, ISliderController, IElementConfiguration<Slider>, ISlider
 	{
+		// Stores the value that was requested by the user, before clamping
+		double _requestedValue = 0d;
+		// Tracks if the user explicitly set Value (vs it being set by recoercion)
+		bool _userSetValue = false;
+		bool _isRecoercing = false;
+
 		/// <summary>Bindable property for <see cref="Minimum"/>.</summary>
-		public static readonly BindableProperty MinimumProperty = BindableProperty.Create(nameof(Minimum), typeof(double), typeof(Slider), 0d, coerceValue: (bindable, value) =>
-		{
-			var slider = (Slider)bindable;
-			slider.Value = slider.Value.Clamp((double)value, slider.Maximum);
-			return value;
-		});
+		public static readonly BindableProperty MinimumProperty = BindableProperty.Create(
+			nameof(Minimum), typeof(double), typeof(Slider), 0d,
+			propertyChanged: (bindable, oldValue, newValue) =>
+			{
+				var slider = (Slider)bindable;
+				slider.RecoerceValue();
+			});
 
 		/// <summary>Bindable property for <see cref="Maximum"/>.</summary>
-		public static readonly BindableProperty MaximumProperty = BindableProperty.Create(nameof(Maximum), typeof(double), typeof(Slider), 1d, coerceValue: (bindable, value) =>
-		{
-			var slider = (Slider)bindable;
-			slider.Value = slider.Value.Clamp(slider.Minimum, (double)value);
-			return value;
-		});
+		public static readonly BindableProperty MaximumProperty = BindableProperty.Create(
+			nameof(Maximum), typeof(double), typeof(Slider), 1d,
+			propertyChanged: (bindable, oldValue, newValue) =>
+			{
+				var slider = (Slider)bindable;
+				slider.RecoerceValue();
+			});
 
 		/// <summary>Bindable property for <see cref="Value"/>.</summary>
 		public static readonly BindableProperty ValueProperty = BindableProperty.Create(nameof(Value), typeof(double), typeof(Slider), 0d, BindingMode.TwoWay, coerceValue: (bindable, value) =>
 		{
 			var slider = (Slider)bindable;
+			// Only store the requested value if the user is setting it (not during recoercion)
+			if (!slider._isRecoercing)
+			{
+				slider._requestedValue = (double)value;
+				slider._userSetValue = true;
+			}
 			return ((double)value).Clamp(slider.Minimum, slider.Maximum);
 		}, propertyChanged: (bindable, oldValue, newValue) =>
 		{
 			var slider = (Slider)bindable;
 			slider.ValueChanged?.Invoke(slider, new ValueChangedEventArgs((double)oldValue, (double)newValue));
 		});
 
+		void RecoerceValue()
+		{
+			_isRecoercing = true;
+			try
+			{
+				// If the user explicitly set Value, try to restore the requested value within the new range
+				if (_userSetValue)
+					Value = _requestedValue;
+				else
+					Value = Value.Clamp(Minimum, Maximum);
+			}
+			finally
+			{
+				_isRecoercing = false;
+			}
+		}
+
 		/// <summary>Bindable property for <see cref="MinimumTrackColor"/>.</summary>
 		public static readonly BindableProperty MinimumTrackColorProperty = BindableProperty.Create(nameof(MinimumTrackColor), typeof(Color), typeof(Slider), null);
 

src/Controls/src/Core/Stepper/Stepper.cs

@@ -10,31 +10,41 @@ namespace Microsoft.Maui.Controls
 	[DebuggerDisplay("{GetDebuggerDisplay(), nq}")]
 	public partial class Stepper : View, IElementConfiguration<Stepper>, IStepper
 	{
+		// Stores the value that was requested by the user, before clamping
+		double _requestedValue = 0d;
+		// Tracks if the user explicitly set Value (vs it being set by recoercion)
+		bool _userSetValue = false;
+		bool _isRecoercing = false;
+
 		/// <summary>Bindable property for <see cref="Maximum"/>.</summary>
 		public static readonly BindableProperty MaximumProperty = BindableProperty.Create(nameof(Maximum), typeof(double), typeof(Stepper), 100.0,
 			validateValue: (bindable, value) => (double)value >= ((Stepper)bindable).Minimum,
-			coerceValue: (bindable, value) =>
+			propertyChanged: (bindable, oldValue, newValue) =>
 			{
 				var stepper = (Stepper)bindable;
-				stepper.Value = stepper.Value.Clamp(stepper.Minimum, (double)value);
-				return value;
+				stepper.RecoerceValue();
 			});
 
 		/// <summary>Bindable property for <see cref="Minimum"/>.</summary>
 		public static readonly BindableProperty MinimumProperty = BindableProperty.Create(nameof(Minimum), typeof(double), typeof(Stepper), 0.0,
 			validateValue: (bindable, value) => (double)value <= ((Stepper)bindable).Maximum,
-			coerceValue: (bindable, value) =>
+			propertyChanged: (bindable, oldValue, newValue) =>
 			{
 				var stepper = (Stepper)bindable;
-				stepper.Value = stepper.Value.Clamp((double)value, stepper.Maximum);
-				return value;
+				stepper.RecoerceValue();
 			});
 
 		/// <summary>Bindable property for <see cref="Value"/>.</summary>
 		public static readonly BindableProperty ValueProperty = BindableProperty.Create(nameof(Value), typeof(double), typeof(Stepper), 0.0, BindingMode.TwoWay,
 			coerceValue: (bindable, value) =>
 			{
 				var stepper = (Stepper)bindable;
+				// Only store the requested value if the user is setting it (not during recoercion)
+				if (!stepper._isRecoercing)
+				{
+					stepper._requestedValue = (double)value;
+					stepper._userSetValue = true;
+				}
 				return Math.Round(((double)value), stepper.digits).Clamp(stepper.Minimum, stepper.Maximum);
 			},
 			propertyChanged: (bindable, oldValue, newValue) =>
@@ -43,6 +53,23 @@ public partial class Stepper : View, IElementConfiguration<Stepper>, IStepper
 				stepper.ValueChanged?.Invoke(stepper, new ValueChangedEventArgs((double)oldValue, (double)newValue));
 			});
 
+		void RecoerceValue()
+		{
+			_isRecoercing = true;
+			try
+			{
+				// If the user explicitly set Value, try to restore the requested value within the new range
+				if (_userSetValue)
+					Value = _requestedValue;
+				else
+					Value = Value.Clamp(Minimum, Maximum);
+			}
+			finally
+			{
+				_isRecoercing = false;
+			}
+		}
+
 		int digits = 4;
 		//'-log10(increment) + 4' as rounding digits gives us 4 significant decimal digits after the most significant one.
 		//If your increment uses more than 4 significant digits, you're holding it wrong.

src/Controls/tests/Core.UnitTests/SliderUnitTests.cs

@@ -19,6 +19,172 @@ public void TestConstructor()
 			Assert.Equal(50, slider.Value);
 		}
 
+		// Tests for setting Min, Max, Value in all 6 possible orders
+		// Order: Min, Max, Value
+		[Theory]
+		[InlineData(10, 100, 50)]
+		[InlineData(0, 1, 0.5)]
+		[InlineData(-100, 100, 0)]
+		[InlineData(50, 150, 100)]
+		public void SetProperties_MinMaxValue_Order(double min, double max, double value)
+		{
+			var slider = new Slider();
+			slider.Minimum = min;
+			slider.Maximum = max;
+			slider.Value = value;
+
+			Assert.Equal(min, slider.Minimum);
+			Assert.Equal(max, slider.Maximum);
+			Assert.Equal(value, slider.Value);
+		}
+
+		// Order: Min, Value, Max
+		[Theory]
+		[InlineData(10, 100, 50)]
+		[InlineData(0, 1, 0.5)]
+		[InlineData(-100, 100, 0)]
+		[InlineData(50, 150, 100)]
+		public void SetProperties_MinValueMax_Order(double min, double max, double value)
+		{
+			var slider = new Slider();
+			slider.Minimum = min;
+			slider.Value = value;
+			slider.Maximum = max;
+
+			Assert.Equal(min, slider.Minimum);
+			Assert.Equal(max, slider.Maximum);
+			Assert.Equal(value, slider.Value);
+		}
+
+		// Order: Max, Min, Value
+		[Theory]
+		[InlineData(10, 100, 50)]
+		[InlineData(0, 1, 0.5)]
+		[InlineData(-100, 100, 0)]
+		[InlineData(50, 150, 100)]
+		public void SetProperties_MaxMinValue_Order(double min, double max, double value)
+		{
+			var slider = new Slider();
+			slider.Maximum = max;
+			slider.Minimum = min;
+			slider.Value = value;
+
+			Assert.Equal(min, slider.Minimum);
+			Assert.Equal(max, slider.Maximum);
+			Assert.Equal(value, slider.Value);
+		}
+
+		// Order: Max, Value, Min
+		[Theory]
+		[InlineData(10, 100, 50)]
+		[InlineData(0, 1, 0.5)]
+		[InlineData(-100, 100, 0)]
+		[InlineData(50, 150, 100)]
+		public void SetProperties_MaxValueMin_Order(double min, double max, double value)
+		{
+			var slider = new Slider();
+			slider.Maximum = max;
+			slider.Value = value;
+			slider.Minimum = min;
+
+			Assert.Equal(min, slider.Minimum);
+			Assert.Equal(max, slider.Maximum);
+			Assert.Equal(value, slider.Value);
+		}
+
+		// Order: Value, Min, Max
+		[Theory]
+		[InlineData(10, 100, 50)]
+		[InlineData(0, 1, 0.5)]
+		[InlineData(-100, 100, 0)]
+		[InlineData(50, 150, 100)]
+		public void SetProperties_ValueMinMax_Order(double min, double max, double value)
+		{
+			var slider = new Slider();
+			slider.Value = value;
+			slider.Minimum = min;
+			slider.Maximum = max;
+
+			Assert.Equal(min, slider.Minimum);
+			Assert.Equal(max, slider.Maximum);
+			Assert.Equal(value, slider.Value);
+		}
+
+		// Order: Value, Max, Min
+		[Theory]
+		[InlineData(10, 100, 50)]
+		[InlineData(0, 1, 0.5)]
+		[InlineData(-100, 100, 0)]
+		[InlineData(50, 150, 100)]
+		public void SetProperties_ValueMaxMin_Order(double min, double max, double value)
+		{
+			var slider = new Slider();
+			slider.Value = value;
+			slider.Maximum = max;
+			slider.Minimum = min;
+
+			Assert.Equal(min, slider.Minimum);
+			Assert.Equal(max, slider.Maximum);
+			Assert.Equal(value, slider.Value);
+		}
+
+		// Tests that _requestedValue is preserved across multiple recoercions
+		[Fact]
+		public void RequestedValuePreservedAcrossMultipleRangeChanges()
+		{
+			var slider = new Slider();
+			slider.Value = 50;
+			slider.Minimum = -10;
+			slider.Maximum = -1; // Value clamped to -1
+
+			Assert.Equal(-1, slider.Value);
+
+			slider.Maximum = -2; // Value should still be clamped, not corrupted
+
+			Assert.Equal(-2, slider.Value);
+
+			slider.Maximum = 100; // Now the original requested value (50) should be restored
+
+			Assert.Equal(50, slider.Value);
+		}
+
+		[Fact]
+		public void RequestedValuePreservedWhenMinimumChangesMultipleTimes()
+		{
+			var slider = new Slider();
+			slider.Value = 5;
+			slider.Maximum = 100;
+			slider.Minimum = 10; // Value clamped to 10
+
+			Assert.Equal(10, slider.Value);
+
+			slider.Minimum = 20; // Value clamped to 20
+
+			Assert.Equal(20, slider.Value);
+
+			slider.Minimum = 0; // Original requested value (5) should be restored
+
+			Assert.Equal(5, slider.Value);
+		}
+
+		[Fact]
+		public void ValueClampedWhenOnlyRangeChanges()
+		{
+			var slider = new Slider(); // Value defaults to 0
+			slider.Minimum = 10; // Value should clamp to 10
+			slider.Maximum = 100;
+
+			Assert.Equal(10, slider.Value);
+
+			slider.Minimum = 5; // Value stays at 10 because 10 is within [5, 100]
+
+			Assert.Equal(10, slider.Value);
+
+			slider.Minimum = 15; // Value clamps to 15
+
+			Assert.Equal(15, slider.Value);
+		}
+
 		[Fact]
 		public void TestInvalidConstructor()
 		{