[C] Fix Slider and Stepper property order independence (#32939)

> [!NOTE]
> Are you waiting for the changes in this PR to be merged?
> It would be very helpful if you could [test the resulting
artifacts](https://github.com/dotnet/maui/wiki/Testing-PR-Builds) from
this PR and let us know in a comment if this change resolves your issue.
Thank you!

## Description

This PR 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).

## Problem

When using XAML data binding, the order in which properties are applied
depends on XAML attribute order and binding evaluation timing. The
previous implementation would clamp `Value` immediately when `Minimum`
or `Maximum` changed, using the current (potentially default) range.
This caused:

- `Value=50` with `Min=10, Max=100` would get clamped to `1` (default
max) if `Value` was set before `Maximum`
- The user's intended value was lost and could never be restored

## Solution

The fix introduces three private fields:
- `_requestedValue`: stores the user's intended value before clamping
- `_userSetValue`: tracks if the user explicitly set `Value` (vs.
automatic recoercion)
- `_isRecoercing`: prevents `_requestedValue` corruption during
recoercion

When `Minimum` or `Maximum` changes:
1. If the user explicitly set `Value`, restore `_requestedValue`
(clamped to new range)
2. If not, just clamp the current value to the new range

This allows `Value` to "spring back" to the user's intended value when
the range expands to include it.

## Issues Fixed

- Fixes #32903 - Slider Binding Initialization Order Causes Incorrect
Value Assignment in XAML
- Fixes #14472 - Slider is very broken, Value is a mess when setting
Minimum
- Fixes #18910 - Slider is buggy depending on order of properties
- Fixes #12243 - Stepper Value is incorrectly clamped to default min/max
when using bindableproperties in MVVM pattern
- Closes #32907
-
## Testing

Added comprehensive unit tests for both `Slider` and `Stepper`:
- All 6 permutations of setting Min, Max, Value in different orders
- Tests for `_requestedValue` preservation across multiple range changes
- Tests for value clamping when only range changes (user didn't set
Value)

**Test Results:** 98 tests passed (39 Slider + 59 Stepper)

## Breaking Changes

**Behavioral change in event ordering:** The order of `PropertyChanged`
events for `Stepper` may change in edge cases where `Minimum`/`Maximum`
changes trigger a `Value` change. Previously, `Value` changed before
`Min`/`Max`; now it changes after. This is an implementation detail and
should not affect correctly-written code.
# Conflicts:
#	src/Controls/tests/Core.UnitTests/StepperUnitTests.cs

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()
 		{