diff --git a/src/Controls/src/Core/BindableObject.cs b/src/Controls/src/Core/BindableObject.cs
index 7bdb15610463..b612a4440fbb 100644
--- a/src/Controls/src/Core/BindableObject.cs
+++ b/src/Controls/src/Core/BindableObject.cs
@@ -361,11 +361,16 @@ public static void SetInheritedBindingContext(BindableObject bindable, object va
 			else
 			{
 				bindable._inheritedContext = new WeakReference(value);
-				bindable.ApplyBindings(fromBindingContextChanged: true);
-				bindable.OnBindingContextChanged();
+				bindable.ApplyBindingsFromBindingContextChanged();
 			}
 		}
 
+		private protected virtual void ApplyBindingsFromBindingContextChanged()
+		{
+			ApplyBindings(fromBindingContextChanged: true);
+			OnBindingContextChanged();
+		}
+
 		/// <summary>
 		/// Applies all the current bindings to <see cref="BindingContext" />.
 		/// </summary>
@@ -717,8 +722,7 @@ static void BindingContextPropertyBindingChanging(BindableObject bindable, Bindi
 		static void BindingContextPropertyChanged(BindableObject bindable, object oldvalue, object newvalue)
 		{
 			bindable._inheritedContext = null;
-			bindable.ApplyBindings(fromBindingContextChanged: true);
-			bindable.OnBindingContextChanged();
+			bindable.ApplyBindingsFromBindingContextChanged();
 		}
 
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/Controls/src/Core/Compatibility/Handlers/ListView/iOS/ListViewRenderer.cs b/src/Controls/src/Core/Compatibility/Handlers/ListView/iOS/ListViewRenderer.cs
index ae7fd8cce6a7..598186cad372 100644
--- a/src/Controls/src/Core/Compatibility/Handlers/ListView/iOS/ListViewRenderer.cs
+++ b/src/Controls/src/Core/Compatibility/Handlers/ListView/iOS/ListViewRenderer.cs
@@ -20,7 +20,7 @@
 
 namespace Microsoft.Maui.Controls.Handlers.Compatibility
 {
-	public class ListViewRenderer : ViewRenderer<ListView, UITableView>
+	public class ListViewRenderer : ViewRenderer<ListView, UITableView>, IPropagatesSetNeedsLayout
 	{
 		public static PropertyMapper<ListView, ListViewRenderer> Mapper =
 				new PropertyMapper<ListView, ListViewRenderer>(VisualElementRendererMapper);
@@ -62,6 +62,33 @@ public ListViewRenderer() : base(Mapper, CommandMapper)
 			AutoPackage = false;
 		}
 
+		bool _pendingSuperViewSetNeedsLayout;
+
+		public override void SetNeedsLayout()
+		{
+			base.SetNeedsLayout();
+
+			if (Window is not null)
+			{
+				_pendingSuperViewSetNeedsLayout = false;
+				Superview?.SetNeedsLayout();
+			}
+			else {
+				_pendingSuperViewSetNeedsLayout = true;
+			}
+		}
+
+		public override void MovedToWindow()
+		{
+			base.MovedToWindow();
+			if (_pendingSuperViewSetNeedsLayout)
+			{
+				Superview?.SetNeedsLayout();
+			}
+
+			_pendingSuperViewSetNeedsLayout = false;
+		}
+
 		public override void LayoutSubviews()
 		{
 			base.LayoutSubviews();
diff --git a/src/Controls/src/Core/Compatibility/Handlers/TableView/iOS/TableViewRenderer.cs b/src/Controls/src/Core/Compatibility/Handlers/TableView/iOS/TableViewRenderer.cs
index b859af8cd439..8c9805d85c1f 100644
--- a/src/Controls/src/Core/Compatibility/Handlers/TableView/iOS/TableViewRenderer.cs
+++ b/src/Controls/src/Core/Compatibility/Handlers/TableView/iOS/TableViewRenderer.cs
@@ -9,7 +9,7 @@
 
 namespace Microsoft.Maui.Controls.Handlers.Compatibility
 {
-	public class TableViewRenderer : ViewRenderer<TableView, UITableView>
+	public class TableViewRenderer : ViewRenderer<TableView, UITableView>, IPropagatesSetNeedsLayout
 	{
 		const int DefaultRowHeight = 44;
 		UIView _originalBackgroundView;
@@ -33,6 +33,33 @@ public override void LayoutSubviews()
 				_previousFrame = Frame;
 		}
 
+		bool _pendingSuperViewSetNeedsLayout;
+
+		public override void SetNeedsLayout()
+		{
+			base.SetNeedsLayout();
+
+			if (Window is not null)
+			{
+				_pendingSuperViewSetNeedsLayout = false;
+				Superview?.SetNeedsLayout();
+			}
+			else {
+				_pendingSuperViewSetNeedsLayout = true;
+			}
+		}
+
+		public override void MovedToWindow()
+		{
+			base.MovedToWindow();
+			if (_pendingSuperViewSetNeedsLayout)
+			{
+				Superview?.SetNeedsLayout();
+			}
+
+			_pendingSuperViewSetNeedsLayout = false;
+		}
+
 		protected override void Dispose(bool disposing)
 		{
 			if (disposing)
diff --git a/src/Controls/src/Core/Compatibility/Handlers/iOS/FrameRenderer.cs b/src/Controls/src/Core/Compatibility/Handlers/iOS/FrameRenderer.cs
index 76b7a3d43c4d..887d91e76cf1 100644
--- a/src/Controls/src/Core/Compatibility/Handlers/iOS/FrameRenderer.cs
+++ b/src/Controls/src/Core/Compatibility/Handlers/iOS/FrameRenderer.cs
@@ -7,7 +7,7 @@
 
 namespace Microsoft.Maui.Controls.Handlers.Compatibility
 {
-	public class FrameRenderer : VisualElementRenderer<Frame>
+	public class FrameRenderer : VisualElementRenderer<Frame>, IPropagatesSetNeedsLayout
 	{
 		public static IPropertyMapper<Frame, FrameRenderer> Mapper
 			= new PropertyMapper<Frame, FrameRenderer>(VisualElementRendererMapper);
diff --git a/src/Controls/src/Core/Internals/InvalidationTriggerFlags.cs b/src/Controls/src/Core/Internals/InvalidationTriggerFlags.cs
new file mode 100644
index 000000000000..f09843ff806e
--- /dev/null
+++ b/src/Controls/src/Core/Internals/InvalidationTriggerFlags.cs
@@ -0,0 +1,43 @@
+using System;
+
+namespace Microsoft.Maui.Controls.Internals;
+
+[Flags]
+internal enum InvalidationTriggerFlags : ushort
+{
+	None = 0,
+	ApplyingBindingContext = 1 << 0,
+	WillNotifyParentMeasureInvalidated = 1 << 1,
+	WillTriggerHorizontalOptionsChanged = 1 << 2,
+	WillTriggerVerticalOptionsChanged = 1 << 3,
+	WillTriggerMarginChanged = 1 << 4,
+	WillTriggerSizeRequestChanged = 1 << 5,
+	WillTriggerMeasureChanged = 1 << 6,
+	WillTriggerRendererReady = 1 << 7,
+	WillTriggerUndefined = 1 << 8,
+}
+
+internal static class InvalidationTriggerFlagsExtensions {
+	public static InvalidationTriggerFlags ToInvalidationTriggerFlags(this InvalidationTrigger trigger) {
+		return trigger switch {
+			InvalidationTrigger.MeasureChanged => InvalidationTriggerFlags.WillTriggerMeasureChanged,
+			InvalidationTrigger.HorizontalOptionsChanged => InvalidationTriggerFlags.WillTriggerHorizontalOptionsChanged,
+			InvalidationTrigger.VerticalOptionsChanged => InvalidationTriggerFlags.WillTriggerVerticalOptionsChanged,
+			InvalidationTrigger.SizeRequestChanged => InvalidationTriggerFlags.WillTriggerSizeRequestChanged,
+			InvalidationTrigger.RendererReady => InvalidationTriggerFlags.WillTriggerRendererReady,
+			InvalidationTrigger.MarginChanged => InvalidationTriggerFlags.WillTriggerMarginChanged,
+			_ => InvalidationTriggerFlags.WillTriggerUndefined,
+		};
+	}
+
+	public static InvalidationTrigger ToInvalidationTrigger(this InvalidationTriggerFlags flags) {
+		if ((flags & InvalidationTriggerFlags.WillTriggerUndefined) != 0) return InvalidationTrigger.Undefined;
+		if ((flags & InvalidationTriggerFlags.WillTriggerRendererReady) != 0) return InvalidationTrigger.RendererReady;
+		if ((flags & InvalidationTriggerFlags.WillTriggerMeasureChanged) != 0) return InvalidationTrigger.MeasureChanged;
+		if ((flags & InvalidationTriggerFlags.WillTriggerSizeRequestChanged) != 0) return InvalidationTrigger.SizeRequestChanged;
+		if ((flags & InvalidationTriggerFlags.WillTriggerMarginChanged) != 0) return InvalidationTrigger.MarginChanged;
+		if ((flags & InvalidationTriggerFlags.WillTriggerVerticalOptionsChanged) != 0) return InvalidationTrigger.VerticalOptionsChanged;
+		if ((flags & InvalidationTriggerFlags.WillTriggerHorizontalOptionsChanged) != 0) return InvalidationTrigger.HorizontalOptionsChanged;
+		return InvalidationTrigger.Undefined;
+	}
+}
\ No newline at end of file
diff --git a/src/Controls/src/Core/LegacyLayouts/Layout.cs b/src/Controls/src/Core/LegacyLayouts/Layout.cs
index 0f3b6d0b0d7f..c254976db9df 100644
--- a/src/Controls/src/Core/LegacyLayouts/Layout.cs
+++ b/src/Controls/src/Core/LegacyLayouts/Layout.cs
@@ -192,8 +192,12 @@ private protected override IList<Element> LogicalChildrenInternalBackingStore
 		public override SizeRequest Measure(double widthConstraint, double heightConstraint, MeasureFlags flags = MeasureFlags.None)
 		{
 			SizeRequest size = base.Measure(widthConstraint - Padding.HorizontalThickness, heightConstraint - Padding.VerticalThickness, flags);
-			return new SizeRequest(new Size(size.Request.Width + Padding.HorizontalThickness, size.Request.Height + Padding.VerticalThickness),
-				new Size(size.Minimum.Width + Padding.HorizontalThickness, size.Minimum.Height + Padding.VerticalThickness));
+			var request = new Size(size.Request.Width + Padding.HorizontalThickness, size.Request.Height + Padding.VerticalThickness);
+			var minimum = new Size(size.Minimum.Width + Padding.HorizontalThickness, size.Minimum.Height + Padding.VerticalThickness);
+
+			DesiredSize = request;
+
+			return new SizeRequest(request, minimum);
 		}
 
 		/// <summary>
@@ -294,13 +298,19 @@ public void RaiseChild(View view)
 			OnChildrenReordered();
 		}
 
+		internal virtual void InvalidateLayoutInternal()
+		{
+			_hasDoneLayout = false;
+			InvalidateMeasureCacheInternal();
+		}
+
 		/// <summary>
 		/// Invalidates the current layout.
 		/// </summary>
 		/// <remarks>Calling this method will invalidate the measure and triggers a new layout cycle.</remarks>
 		protected virtual void InvalidateLayout()
 		{
-			_hasDoneLayout = false;
+			InvalidateLayoutInternal();
 			InvalidateMeasureInternal(InvalidationTrigger.MeasureChanged);
 			if (!_hasDoneLayout)
 			{
@@ -319,10 +329,15 @@ protected virtual void InvalidateLayout()
 		/// It is suggested to still call the base method and modify its calculated results.</remarks>
 		protected abstract void LayoutChildren(double x, double y, double width, double height);
 
-		internal override void OnChildMeasureInvalidatedInternal(VisualElement child, InvalidationTrigger trigger)
+		internal override bool OnChildMeasureInvalidatedInternal(VisualElement child, InvalidationTrigger trigger)
 		{
-			// TODO: once we remove old Xamarin public signatures we can invoke `OnChildMeasureInvalidated(VisualElement, InvalidationTrigger)` directly
-			OnChildMeasureInvalidated(child, new InvalidationEventArgs(trigger));
+			if (base.OnChildMeasureInvalidatedInternal(child, trigger))
+			{
+				OnChildMeasureInvalidated(child, new InvalidationEventArgs(trigger));
+				return true;
+			}
+
+			return false;
 		}
 
 		/// <summary>
@@ -334,8 +349,7 @@ internal override void OnChildMeasureInvalidatedInternal(VisualElement child, In
 		/// <remarks>This method has a default implementation and application developers must call the base implementation.</remarks>
 		protected void OnChildMeasureInvalidated(object sender, EventArgs e)
 		{
-			InvalidationTrigger trigger = (e as InvalidationEventArgs)?.Trigger ?? InvalidationTrigger.Undefined;
-			OnChildMeasureInvalidated((VisualElement)sender, trigger);
+			InvalidateLayoutInternal();
 			OnChildMeasureInvalidated();
 		}
 
@@ -497,42 +511,6 @@ internal static void LayoutChildIntoBoundingRegion(View child, Rect region, Size
 			child.Layout(region);
 		}
 
-		internal virtual void OnChildMeasureInvalidated(VisualElement child, InvalidationTrigger trigger)
-		{
-			IReadOnlyList<Element> children = LogicalChildrenInternal;
-			int count = children.Count;
-			for (var index = 0; index < count; index++)
-			{
-				if (LogicalChildrenInternal[index] is VisualElement v && v.IsVisible && (!v.IsPlatformEnabled || !v.IsPlatformStateConsistent))
-				{
-					return;
-				}
-			}
-
-			if (child is View view)
-			{
-				// we can ignore the request if we are either fully constrained or when the size request changes and we were already fully constrained
-				if ((trigger == InvalidationTrigger.MeasureChanged && view.Constraint == LayoutConstraint.Fixed) ||
-					(trigger == InvalidationTrigger.SizeRequestChanged && view.ComputedConstraint == LayoutConstraint.Fixed))
-				{
-					return;
-				}
-				if (trigger == InvalidationTrigger.HorizontalOptionsChanged || trigger == InvalidationTrigger.VerticalOptionsChanged)
-				{
-					ComputeConstraintForView(view);
-				}
-			}
-
-			if (trigger == InvalidationTrigger.RendererReady)
-			{
-				InvalidateMeasureInternal(InvalidationTrigger.RendererReady);
-			}
-			else
-			{
-				InvalidateMeasureInternal(InvalidationTrigger.MeasureChanged);
-			}
-		}
-
 		internal override void OnIsVisibleChanged(bool oldValue, bool newValue)
 		{
 			base.OnIsVisibleChanged(oldValue, newValue);
@@ -645,15 +623,8 @@ bool ShouldLayoutChildren()
 
 		protected override void InvalidateMeasureOverride()
 		{
+			InvalidateLayoutInternal();
 			base.InvalidateMeasureOverride();
-
-			foreach (var child in ((IElementController)this).LogicalChildren)
-			{
-				if (child is IView fe)
-				{
-					fe.InvalidateMeasure();
-				}
-			}
 		}
 
 		protected override Size ArrangeOverride(Rect bounds)
diff --git a/src/Controls/src/Core/LegacyLayouts/StackLayout.cs b/src/Controls/src/Core/LegacyLayouts/StackLayout.cs
index db341b2df4d4..c2aa1e9f94fe 100644
--- a/src/Controls/src/Core/LegacyLayouts/StackLayout.cs
+++ b/src/Controls/src/Core/LegacyLayouts/StackLayout.cs
@@ -92,10 +92,16 @@ internal override void ComputeConstraintForView(View view)
 			ComputeConstraintForView(view, false);
 		}
 
-		internal override void InvalidateMeasureInternal(InvalidationTrigger trigger)
+		internal override void InvalidateLayoutInternal()
 		{
+			base.InvalidateLayoutInternal();
 			_layoutInformation = new LayoutInformation();
-			base.InvalidateMeasureInternal(trigger);
+		}
+
+		internal override void InvalidateMeasureInternal(InvalidationTriggerFlags flags)
+		{
+			InvalidateLayoutInternal();
+			base.InvalidateMeasureInternal(flags);
 		}
 
 		void AlignOffAxis(LayoutInformation layout, StackOrientation orientation, double widthConstraint, double heightConstraint)
diff --git a/src/Controls/src/Core/Page/Page.cs b/src/Controls/src/Core/Page/Page.cs
index 53b083d64504..2339a15fd27c 100644
--- a/src/Controls/src/Core/Page/Page.cs
+++ b/src/Controls/src/Core/Page/Page.cs
@@ -497,10 +497,44 @@ protected override void OnBindingContextChanged()
 				SetInheritedBindingContext(TitleView, BindingContext);
 		}
 		
-		internal override void OnChildMeasureInvalidatedInternal(VisualElement child, InvalidationTrigger trigger)
+		internal override bool OnChildMeasureInvalidatedInternal(VisualElement child, InvalidationTrigger trigger)
 		{
-			// TODO: once we remove old Xamarin public signatures we can invoke `OnChildMeasureInvalidated(VisualElement, InvalidationTrigger)` directly
+			// Behave like `VisualElement` except for propagation to parent
+			switch (trigger)
+			{
+				case InvalidationTrigger.Undefined:
+					if (IsApplyingBindings)
+					{
+						// If we're applying bindings, we need to wait until it's done to invalidate the measure
+						MeasureInvalidationStatus |= InvalidationTriggerFlags.WillNotifyParentMeasureInvalidated;
+						return false;
+					}
+
+					InvokeMeasureInvalidated(InvalidationTrigger.MeasureChanged);
+					break;
+
+				default:
+					// When visibility changes `InvalidationTrigger.Undefined` is used,
+					// so here we're sure that visibility didn't change
+					if (child.IsVisible)
+					{
+						if (IsApplyingBindings)
+						{
+							// If we're applying bindings, we need to wait until it's done to invalidate the measure
+							MeasureInvalidationStatus |= InvalidationTriggerFlags.WillNotifyParentMeasureInvalidated;
+							return false;
+						}
+
+						// We need to invalidate measures only if child is actually visible
+						InvokeMeasureInvalidated(InvalidationTrigger.MeasureChanged);
+					}
+					break;
+			}
+
+			// We still need to call the legacy OnChildMeasureInvalidated to keep the compatibility.
 			OnChildMeasureInvalidated(child, new InvalidationEventArgs(trigger));
+
+			return true;
 		}
 
 		/// <summary>
@@ -510,8 +544,7 @@ internal override void OnChildMeasureInvalidatedInternal(VisualElement child, In
 		/// <param name="e">The event arguments.</param>
 		protected virtual void OnChildMeasureInvalidated(object sender, EventArgs e)
 		{
-			InvalidationTrigger trigger = (e as InvalidationEventArgs)?.Trigger ?? InvalidationTrigger.Undefined;
-			OnChildMeasureInvalidated((VisualElement)sender, trigger);
+			// Nothing to do here: platform will take care of arranging the children if needed on the next layout pass
 		}
 
 		/// <summary>
@@ -583,29 +616,6 @@ protected void UpdateChildrenLayout()
 			}
 		}
 
-		internal virtual void OnChildMeasureInvalidated(VisualElement child, InvalidationTrigger trigger)
-		{
-			var container = this as IPageContainer<Page>;
-			if (container != null)
-			{
-				Page page = container.CurrentPage;
-				if (page != null && page.IsVisible && (!page.IsPlatformEnabled || !page.IsPlatformStateConsistent))
-					return;
-			}
-			else
-			{
-				var logicalChildren = this.InternalChildren;
-				for (var i = 0; i < logicalChildren.Count; i++)
-				{
-					var v = logicalChildren[i] as VisualElement;
-					if (v != null && v.IsVisible && (!v.IsPlatformEnabled || !v.IsPlatformStateConsistent))
-						return;
-				}
-			}
-
-			InvalidateMeasureInternal(InvalidationTrigger.MeasureChanged);
-		}
-
 		internal void OnAppearing(Action action)
 		{
 			if (_hasAppeared)
diff --git a/src/Controls/src/Core/PublicAPI/net-ios/PublicAPI.Unshipped.txt b/src/Controls/src/Core/PublicAPI/net-ios/PublicAPI.Unshipped.txt
index f8ec2fad5146..466ec2bb0686 100644
--- a/src/Controls/src/Core/PublicAPI/net-ios/PublicAPI.Unshipped.txt
+++ b/src/Controls/src/Core/PublicAPI/net-ios/PublicAPI.Unshipped.txt
@@ -1,2 +1,6 @@
 #nullable enable
 override Microsoft.Maui.Controls.Handlers.Compatibility.FrameRenderer.MovedToWindow() -> void
+override Microsoft.Maui.Controls.Handlers.Compatibility.ListViewRenderer.MovedToWindow() -> void
+override Microsoft.Maui.Controls.Handlers.Compatibility.ListViewRenderer.SetNeedsLayout() -> void
+override Microsoft.Maui.Controls.Handlers.Compatibility.TableViewRenderer.MovedToWindow() -> void
+override Microsoft.Maui.Controls.Handlers.Compatibility.TableViewRenderer.SetNeedsLayout() -> void
diff --git a/src/Controls/src/Core/PublicAPI/net-maccatalyst/PublicAPI.Unshipped.txt b/src/Controls/src/Core/PublicAPI/net-maccatalyst/PublicAPI.Unshipped.txt
index 182b9e67b45a..910585c9d0e9 100644
--- a/src/Controls/src/Core/PublicAPI/net-maccatalyst/PublicAPI.Unshipped.txt
+++ b/src/Controls/src/Core/PublicAPI/net-maccatalyst/PublicAPI.Unshipped.txt
@@ -1,2 +1,6 @@
 #nullable enable
-override Microsoft.Maui.Controls.Handlers.Compatibility.FrameRenderer.MovedToWindow() -> void
\ No newline at end of file
+override Microsoft.Maui.Controls.Handlers.Compatibility.FrameRenderer.MovedToWindow() -> void
+override Microsoft.Maui.Controls.Handlers.Compatibility.ListViewRenderer.MovedToWindow() -> void
+override Microsoft.Maui.Controls.Handlers.Compatibility.ListViewRenderer.SetNeedsLayout() -> void
+override Microsoft.Maui.Controls.Handlers.Compatibility.TableViewRenderer.MovedToWindow() -> void
+override Microsoft.Maui.Controls.Handlers.Compatibility.TableViewRenderer.SetNeedsLayout() -> void
\ No newline at end of file
diff --git a/src/Controls/src/Core/VisualElement/VisualElement.cs b/src/Controls/src/Core/VisualElement/VisualElement.cs
index 24946eb7c3d5..56a3ad70adad 100644
--- a/src/Controls/src/Core/VisualElement/VisualElement.cs
+++ b/src/Controls/src/Core/VisualElement/VisualElement.cs
@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Globalization;
+using System.Runtime.CompilerServices;
 using Microsoft.Maui.Controls.Internals;
 using Microsoft.Maui.Controls.Shapes;
 using Microsoft.Maui.Graphics;
@@ -919,6 +920,12 @@ public Geometry Clip
 		[EditorBrowsable(EditorBrowsableState.Never)]
 		public bool Batched => _batched > 0;
 
+		/// <summary>
+		/// Legacy <see cref="Compatibility.Layout"/>s can force <see cref="LayoutConstraint.Fixed"/> flags on the element.
+		/// </summary>
+		/// <remarks>
+		/// This should be removed once we drop the legacy layout system, unless we decide to implement a similar functionality in the new layout system.
+		/// </remarks>
 		internal LayoutConstraint ComputedConstraint
 		{
 			get { return _computedConstraint; }
@@ -935,6 +942,9 @@ internal LayoutConstraint ComputedConstraint
 			}
 		}
 
+		/// <summary>
+		/// This flag is substantially used by to avoid measure invalidation when the view is <see cref="LayoutConstraint.Fixed"/>.
+		/// </summary>
 		internal LayoutConstraint Constraint => ComputedConstraint | SelfConstraint;
 
 		/// <summary>
@@ -991,7 +1001,7 @@ public bool IsPlatformStateConsistent
 		internal event EventHandler PlatformEnabledChanged;
 
 		/// <summary>
-		/// Gets or sets a value that indicates whether this elements's platform equivalent element is enabled.
+		/// Gets or sets a value that indicates whether this element's platform equivalent element is enabled.
 		/// </summary>
 		/// <remarks>For internal use only. This API can be changed or removed without notice at any time.</remarks>
 		[EditorBrowsable(EditorBrowsableState.Never)]
@@ -1354,56 +1364,146 @@ public void InvalidateMeasureNonVirtual(InvalidationTrigger trigger)
 		{
 			InvalidateMeasureInternal(trigger);
 		}
+		
+		internal void InvokeMeasureInvalidated(InvalidationTrigger trigger)
+		{
+			MeasureInvalidated?.Invoke(this, new InvalidationEventArgs(trigger));
+		}
 
-		internal virtual void InvalidateMeasureInternal(InvalidationTrigger trigger)
+		private protected InvalidationTriggerFlags MeasureInvalidationStatus;
+		private protected bool IsApplyingBindings => (MeasureInvalidationStatus & InvalidationTriggerFlags.ApplyingBindingContext) != 0;
+
+		private protected override void ApplyBindingsFromBindingContextChanged()
 		{
-			_measureCache.Clear();
+			try
+			{
+				MeasureInvalidationStatus |= InvalidationTriggerFlags.ApplyingBindingContext;
+				base.ApplyBindingsFromBindingContextChanged();
+			}
+			finally
+			{
+				var status = MeasureInvalidationStatus;
+				MeasureInvalidationStatus = InvalidationTriggerFlags.None;
+				if (status > InvalidationTriggerFlags.ApplyingBindingContext)
+				{
+					InvalidateMeasureInternal(status);
+				}
+			}
+		}
 
-			// TODO ezhart Once we get InvalidateArrange sorted, HorizontalOptionsChanged and 
-			// VerticalOptionsChanged will need to call ParentView.InvalidateArrange() instead
+		internal virtual void InvalidateMeasureInternal(InvalidationTriggerFlags flags)
+		{
+			var parentVisualElement = Parent as VisualElement;
 
-			switch (trigger)
+			const InvalidationTriggerFlags notifyOnly = InvalidationTriggerFlags.WillNotifyParentMeasureInvalidated |
+			                                            InvalidationTriggerFlags.ApplyingBindingContext;
+
+			// While applying bindings we only received `OnChildMeasureInvalidatedInternal` calls, so just propagate one of them
+			if (flags <= notifyOnly)
+			{
+				InvokeMeasureInvalidated(InvalidationTrigger.MeasureChanged);
+				// Notify parent chain that a child's measure has been invalidated
+				parentVisualElement?.OnChildMeasureInvalidatedInternal(this, InvalidationTrigger.MeasureChanged);
+				return;
+			}
+
+			const InvalidationTriggerFlags positionOptionsChanged = InvalidationTriggerFlags.WillTriggerHorizontalOptionsChanged | InvalidationTriggerFlags.WillTriggerVerticalOptionsChanged;
+
+			// If position options changed, we need to recompute constraints
+			if ((flags & positionOptionsChanged) != 0 && parentVisualElement != null && this is View thisView)
+			{
+				parentVisualElement.ComputeConstraintForView(thisView);
+			}
+
+			var invalidationTrigger = flags.ToInvalidationTrigger();
+
+			// If this view's measure has not been invalidated, we can trigger the invalidation on parent only
+			if (flags < InvalidationTriggerFlags.WillTriggerSizeRequestChanged)
 			{
-				case InvalidationTrigger.MarginChanged:
-				case InvalidationTrigger.HorizontalOptionsChanged:
-				case InvalidationTrigger.VerticalOptionsChanged:
+				InvokeMeasureInvalidated(invalidationTrigger);
+
+				// Trigger parent measure invalidation
+				if (parentVisualElement is not null)
+				{
+					parentVisualElement.InvalidateMeasure();
+				}
+				else
+				{
+					// This should never happen, but just in case, the only thing we can do is invalidate the platform view
 					ParentView?.InvalidateMeasure();
-					break;
-				default:
-					(this as IView)?.InvalidateMeasure();
-					break;
+				}
+				return;
 			}
 
-			MeasureInvalidated?.Invoke(this, new InvalidationEventArgs(trigger));
-			(Parent as VisualElement)?.OnChildMeasureInvalidatedInternal(this, trigger);
+			InvalidateMeasureCacheInternal();
+			((IView)this).InvalidateMeasure();
+			InvokeMeasureInvalidated(invalidationTrigger);
+			// Notify parent chain that a child's measure has been invalidated
+			(Parent as VisualElement)?.OnChildMeasureInvalidatedInternal(this, invalidationTrigger);
 		}
-		
-		internal virtual void OnChildMeasureInvalidatedInternal(VisualElement child, InvalidationTrigger trigger)
+
+		internal void InvalidateMeasureInternal(InvalidationTrigger trigger)
+		{
+			if (!IsPlatformEnabled)
+			{
+				// No need to invalidate measure if there's no platform view
+				return;
+			}
+
+			if (IsApplyingBindings)
+			{
+				// If we're applying bindings, we need to wait until it's done to invalidate the measure
+				MeasureInvalidationStatus |= trigger.ToInvalidationTriggerFlags();
+				return;
+			}
+
+			InvalidateMeasureInternal(trigger.ToInvalidationTriggerFlags());
+		}
+
+		/// <summary>
+		/// Clears the measure cache of a visual element.
+		/// </summary>
+		internal void InvalidateMeasureCacheInternal()
+		{
+			_measureCache.Clear();
+		}
+
+		internal virtual bool OnChildMeasureInvalidatedInternal(VisualElement child, InvalidationTrigger trigger)
 		{
 			switch (trigger)
 			{
-				case InvalidationTrigger.VerticalOptionsChanged:
-				case InvalidationTrigger.HorizontalOptionsChanged:
-					// When a child changes its HorizontalOptions or VerticalOptions
-					// the size of the parent won't change, so we don't have to invalidate the measure
-					return;
-				case InvalidationTrigger.RendererReady:
-				// Undefined happens in many cases, including when `IsVisible` changes
 				case InvalidationTrigger.Undefined:
-					MeasureInvalidated?.Invoke(this, new InvalidationEventArgs(trigger));
-					(Parent as VisualElement)?.OnChildMeasureInvalidatedInternal(this, trigger);
-					return;
+					if (IsApplyingBindings)
+					{
+						// If we're applying bindings, we need to wait until it's done to invalidate the measure
+						MeasureInvalidationStatus |= InvalidationTriggerFlags.WillNotifyParentMeasureInvalidated;
+						return false;
+					}
+
+					InvokeMeasureInvalidated(InvalidationTrigger.MeasureChanged);
+					(Parent as VisualElement)?.OnChildMeasureInvalidatedInternal(this, InvalidationTrigger.MeasureChanged);
+					break;
+
 				default:
 					// When visibility changes `InvalidationTrigger.Undefined` is used,
 					// so here we're sure that visibility didn't change
 					if (child.IsVisible)
 					{
 						// We need to invalidate measures only if child is actually visible
-						MeasureInvalidated?.Invoke(this, new InvalidationEventArgs(InvalidationTrigger.MeasureChanged));
+						if (IsApplyingBindings)
+						{
+							// If we're applying bindings, we need to wait until it's done to invalidate the measure
+							MeasureInvalidationStatus |= InvalidationTriggerFlags.WillNotifyParentMeasureInvalidated;
+							return false;
+						}
+
+						InvokeMeasureInvalidated(InvalidationTrigger.MeasureChanged);
 						(Parent as VisualElement)?.OnChildMeasureInvalidatedInternal(this, InvalidationTrigger.MeasureChanged);
 					}
-					return;
+					break;
 			}
+
+			return true;
 		}
 
 		/// <inheritdoc/>
diff --git a/src/Controls/tests/Core.UnitTests/ButtonUnitTest.cs b/src/Controls/tests/Core.UnitTests/ButtonUnitTest.cs
index f5ffd00a3d8d..154bd8508078 100644
--- a/src/Controls/tests/Core.UnitTests/ButtonUnitTest.cs
+++ b/src/Controls/tests/Core.UnitTests/ButtonUnitTest.cs
@@ -10,7 +10,7 @@ public class ButtonUnitTest : VisualElementCommandSourceTests<Button>
 		[Fact]
 		public void MeasureInvalidatedOnTextChange()
 		{
-			var button = new Button();
+			var button = new Button { IsPlatformEnabled = true };
 
 			bool fired = false;
 			button.MeasureInvalidated += (sender, args) => fired = true;
@@ -123,7 +123,7 @@ public void TestBindingContextPropagation()
 		public void TestImageSourcePropertiesChangedTriggerResize()
 		{
 			var source = new FileImageSource();
-			var button = new Button { ImageSource = source };
+			var button = new Button { ImageSource = source, IsPlatformEnabled = true };
 			bool fired = false;
 			button.MeasureInvalidated += (sender, e) => fired = true;
 			Assert.Null(source.File);
diff --git a/src/Controls/tests/Core.UnitTests/GridTests.cs b/src/Controls/tests/Core.UnitTests/GridTests.cs
index 82c8077b9d76..2c30c314a43c 100644
--- a/src/Controls/tests/Core.UnitTests/GridTests.cs
+++ b/src/Controls/tests/Core.UnitTests/GridTests.cs
@@ -1329,7 +1329,7 @@ public void TestEnd()
 		[Fact]
 		public void TestDefaultRowSpacing()
 		{
-			var layout = new Grid();
+			var layout = new Grid { IsPlatformEnabled = true };
 
 			bool preferredSizeChanged = false;
 			layout.MeasureInvalidated += (sender, args) =>
@@ -1349,7 +1349,7 @@ public void TestDefaultRowSpacing()
 		[Fact]
 		public void TestDefaultColumnSpacing()
 		{
-			var layout = new Grid();
+			var layout = new Grid { IsPlatformEnabled = true };
 
 			bool preferredSizeChanged = false;
 			layout.MeasureInvalidated += (sender, args) =>
@@ -1369,7 +1369,7 @@ public void TestDefaultColumnSpacing()
 		[Fact]
 		public void TestAddCell()
 		{
-			var layout = new Grid();
+			var layout = new Grid { IsPlatformEnabled = true };
 			bool preferredSizeChanged = false;
 			layout.MeasureInvalidated += (sender, args) => preferredSizeChanged = true;
 
@@ -1383,7 +1383,7 @@ public void TestAddCell()
 		[Fact]
 		public void TestMoveCell()
 		{
-			var layout = new Grid();
+			var layout = new Grid { IsPlatformEnabled = true };
 			var label = new Label();
 			layout.Children.Add(label, 0, 0);
 
diff --git a/src/Controls/tests/Core.UnitTests/ImageButtonUnitTest.cs b/src/Controls/tests/Core.UnitTests/ImageButtonUnitTest.cs
index 4b5a2f5a0f5c..3e99948e0830 100644
--- a/src/Controls/tests/Core.UnitTests/ImageButtonUnitTest.cs
+++ b/src/Controls/tests/Core.UnitTests/ImageButtonUnitTest.cs
@@ -93,7 +93,7 @@ public void TestFillSizingWithConstrainedWidth()
 		[Fact]
 		public void TestSizeChanged()
 		{
-			var image = new ImageButton { Source = "File0.png" };
+			var image = new ImageButton { Source = "File0.png", IsPlatformEnabled = true };
 			Assert.Equal("File0.png", ((FileImageSource)image.Source).File);
 
 			var preferredSizeChanged = false;
@@ -163,7 +163,7 @@ public void TestFileImageSourceChanged()
 		public void TestFileImageSourcePropertiesChangedTriggerResize()
 		{
 			var source = new FileImageSource();
-			var image = new ImageButton { Source = source };
+			var image = new ImageButton { Source = source, IsPlatformEnabled = true };
 			bool fired = false;
 			image.MeasureInvalidated += (sender, e) => fired = true;
 			Assert.Null(source.File);
@@ -176,7 +176,7 @@ public void TestFileImageSourcePropertiesChangedTriggerResize()
 		public void TestStreamImageSourcePropertiesChangedTriggerResize()
 		{
 			var source = new StreamImageSource();
-			var image = new ImageButton { Source = source };
+			var image = new ImageButton { Source = source, IsPlatformEnabled = true };
 			bool fired = false;
 			EventHandler eventHandler = (sender, e) => fired = true;
 			image.MeasureInvalidated += eventHandler;
@@ -370,7 +370,7 @@ public void TestBindingContextPropagation()
 		public void TestImageSourcePropertiesChangedTriggerResize()
 		{
 			var source = new FileImageSource();
-			var button = new ImageButton { Source = source };
+			var button = new ImageButton { Source = source, IsPlatformEnabled = true };
 			bool fired = false;
 			button.MeasureInvalidated += (sender, e) => fired = true;
 			Assert.Null(source.File);
diff --git a/src/Controls/tests/Core.UnitTests/ImageTests.cs b/src/Controls/tests/Core.UnitTests/ImageTests.cs
index 4bb76dd868c0..cee3065203ee 100644
--- a/src/Controls/tests/Core.UnitTests/ImageTests.cs
+++ b/src/Controls/tests/Core.UnitTests/ImageTests.cs
@@ -95,7 +95,7 @@ public void TestFillSizingWithConstrainedWidth()
 		[Fact]
 		public void TestSizeChanged()
 		{
-			var image = new Image { Source = "File0.png" };
+			var image = new Image { Source = "File0.png", IsPlatformEnabled = true };
 			Assert.Equal("File0.png", ((FileImageSource)image.Source).File);
 
 			var preferredSizeChanged = false;
@@ -165,7 +165,7 @@ public void TestFileImageSourceChanged()
 		public void TestFileImageSourcePropertiesChangedTriggerResize()
 		{
 			var source = new FileImageSource();
-			var image = new Image { Source = source };
+			var image = new Image { Source = source, IsPlatformEnabled = true };
 			bool fired = false;
 			image.MeasureInvalidated += (sender, e) => fired = true;
 			Assert.Null(source.File);
@@ -178,7 +178,7 @@ public void TestFileImageSourcePropertiesChangedTriggerResize()
 		public void TestStreamImageSourcePropertiesChangedTriggerResize()
 		{
 			var source = new StreamImageSource();
-			var image = new Image { Source = source };
+			var image = new Image { Source = source, IsPlatformEnabled = true };
 			bool fired = false;
 			image.MeasureInvalidated += (sender, e) => fired = true;
 			Assert.Null(source.Stream);
diff --git a/src/Controls/tests/Core.UnitTests/InvalidationTriggerTests.cs b/src/Controls/tests/Core.UnitTests/InvalidationTriggerTests.cs
new file mode 100644
index 000000000000..a6cc7cc2e7fc
--- /dev/null
+++ b/src/Controls/tests/Core.UnitTests/InvalidationTriggerTests.cs
@@ -0,0 +1,85 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Maui.Controls.Internals;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.Core.UnitTests
+{
+	public class InvalidationTriggerTests : BaseTestFixture
+	{
+		[Theory]
+		[InlineData(InvalidationTrigger.MeasureChanged)]
+		[InlineData(InvalidationTrigger.HorizontalOptionsChanged)]
+		[InlineData(InvalidationTrigger.VerticalOptionsChanged)]
+		[InlineData(InvalidationTrigger.SizeRequestChanged)]
+		[InlineData(InvalidationTrigger.RendererReady)]
+		[InlineData(InvalidationTrigger.MarginChanged)]
+		[InlineData(InvalidationTrigger.Undefined)]
+		public void InvalidationTriggerConvertsToFlagsAndBack(InvalidationTrigger trigger)
+		{
+			var flags = trigger.ToInvalidationTriggerFlags();
+			var result = flags.ToInvalidationTrigger();
+
+			Assert.Equal(trigger, result);
+		}
+
+		[Fact]
+		public void InvalidationTriggerFlagsConvertsToHigherInvalidationTrigger()
+		{
+			foreach (var (flags, expected) in GetInvalidationTriggerFlagsConversionExpectations())
+			{
+				var result = ((InvalidationTriggerFlags)flags).ToInvalidationTrigger();
+				Assert.Equal(expected, result);
+			}
+		}
+		
+		public static IEnumerable<(ushort Flags, InvalidationTrigger Trigger)> GetInvalidationTriggerFlagsConversionExpectations()
+		{
+			var flagsByImportance = new[] {
+				InvalidationTriggerFlags.WillTriggerUndefined,
+				InvalidationTriggerFlags.WillTriggerRendererReady,
+				InvalidationTriggerFlags.WillTriggerMeasureChanged,
+				InvalidationTriggerFlags.WillTriggerSizeRequestChanged,
+				InvalidationTriggerFlags.WillTriggerMarginChanged,
+				InvalidationTriggerFlags.WillTriggerVerticalOptionsChanged,
+				InvalidationTriggerFlags.WillTriggerHorizontalOptionsChanged,
+				InvalidationTriggerFlags.WillNotifyParentMeasureInvalidated,
+				InvalidationTriggerFlags.ApplyingBindingContext
+			};
+
+			var invalidationTriggerExpected = new []
+			{
+				InvalidationTrigger.Undefined,
+				InvalidationTrigger.RendererReady,
+				InvalidationTrigger.MeasureChanged,
+				InvalidationTrigger.SizeRequestChanged,
+				InvalidationTrigger.MarginChanged,
+				InvalidationTrigger.VerticalOptionsChanged,
+				InvalidationTrigger.HorizontalOptionsChanged,
+				InvalidationTrigger.Undefined,
+				InvalidationTrigger.Undefined
+			};
+
+			for (int i = 0; i < flagsByImportance.Length; i++)
+			{
+				var baseFlag = flagsByImportance[i];
+				var expected = invalidationTriggerExpected[i];
+				var remainingFlags = flagsByImportance.Skip(i + 1).ToArray();
+				foreach (InvalidationTriggerFlags combination in Combinations(remainingFlags))
+				{
+					yield return ((ushort)(baseFlag | combination), expected);
+				}
+			}
+		}
+
+		private static IEnumerable<InvalidationTriggerFlags> Combinations(InvalidationTriggerFlags[] data) {
+			// https://stackoverflow.com/a/57058345
+			return Enumerable
+				.Range(0, 1 << data.Length)
+				.Select(index => data
+					.Where((v, i) => (index & (1 << i)) != 0)
+					.DefaultIfEmpty()
+					.Aggregate((a, b) => a | b));
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Controls/tests/Core.UnitTests/LabelTests.cs b/src/Controls/tests/Core.UnitTests/LabelTests.cs
index 38d28312577d..f6ae0ebd9497 100644
--- a/src/Controls/tests/Core.UnitTests/LabelTests.cs
+++ b/src/Controls/tests/Core.UnitTests/LabelTests.cs
@@ -33,7 +33,7 @@ public void TextAndAttributedTextMutuallyExclusive()
 		[Fact]
 		public void InvalidateMeasureWhenTextChanges()
 		{
-			var label = new Label();
+			var label = new Label { IsPlatformEnabled = true };
 
 			bool fired;
 			label.MeasureInvalidated += (sender, args) =>
diff --git a/src/Controls/tests/Core.UnitTests/MeasureInvalidationTests.cs b/src/Controls/tests/Core.UnitTests/MeasureInvalidationTests.cs
new file mode 100644
index 000000000000..0e8b7144ae87
--- /dev/null
+++ b/src/Controls/tests/Core.UnitTests/MeasureInvalidationTests.cs
@@ -0,0 +1,298 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Maui.Controls.Internals;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.Core.UnitTests
+{
+	public class MeasureInvalidationTests : BaseTestFixture
+	{
+		private class MeasureInvalidatedExpectations
+		{
+			public IReadOnlyList<(View Target, InvalidationTrigger Trigger)> Events { get; init; }
+		}
+
+		[Fact]
+		public void VisualElementWhenHandlerIsSetInvalidatesWithRendererReady()
+		{
+			var expectations = TestMeasureInvalidation(
+				(view, parentView) =>
+				{
+					view.Handler = null;
+					view.Handler = new HandlerStub();
+				},
+				out var element,
+				out var parent);
+
+			Assert.Equal(1, element.InvalidateMeasureCount);
+			Assert.Equal(0, parent.ComputeConstraintCount);
+			Assert.Equal(0, parent.InvalidateMeasureCount);
+			AssertEvents(expectations.Events, 
+				(element, InvalidationTrigger.RendererReady),
+				(parent, InvalidationTrigger.MeasureChanged));
+		}
+
+		[Fact]
+		public void VisualElementWhenSizeRequestIsSetInvalidatesWithSizeRequestChanged()
+		{
+			var expectations = TestMeasureInvalidation(
+				(view, parentView) =>
+				{
+					view.HeightRequest = 100;
+				},
+				out var element,
+				out var parent);
+
+			Assert.Equal(1, element.InvalidateMeasureCount);
+			Assert.Equal(0, parent.ComputeConstraintCount);
+			Assert.Equal(0, parent.InvalidateMeasureCount);
+			AssertEvents(expectations.Events, 
+				(element, InvalidationTrigger.SizeRequestChanged),
+				(parent, InvalidationTrigger.MeasureChanged));
+		}
+
+		[Fact]
+		public void VisualElementWhenMeasureChangedInvalidatesWithMeasureChanged()
+		{
+			var expectations = TestMeasureInvalidation(
+				(view, parentView) =>
+				{
+					view.PlatformSizeChanged();
+				},
+				out var element,
+				out var parent);
+
+			Assert.Equal(1, element.InvalidateMeasureCount);
+			Assert.Equal(0, parent.ComputeConstraintCount);
+			Assert.Equal(0, parent.InvalidateMeasureCount);
+			AssertEvents(expectations.Events, 
+				(element, InvalidationTrigger.MeasureChanged),
+				(parent, InvalidationTrigger.MeasureChanged));
+		}
+
+		[Fact]
+		public void VisualElementWhenIsVisibleChangesInvalidatesWithUndefined()
+		{
+			var expectations = TestMeasureInvalidation(
+				(view, parentView) =>
+				{
+					view.IsVisible = false;
+				},
+				out var element,
+				out var parent);
+
+			Assert.Equal(0, parent.ComputeConstraintCount);
+			AssertEvents(expectations.Events, 
+				(element, InvalidationTrigger.Undefined),
+				(parent, InvalidationTrigger.MeasureChanged));
+		}
+
+		[Fact]
+		public void VisualElementWhenHorizontalOptionsChangesInvalidatesWithHorizontalOptionsChanged()
+		{
+			var expectations = TestMeasureInvalidation(
+				(view, parentView) =>
+				{
+					view.HorizontalOptions = LayoutOptions.Center;
+				},
+				out var element,
+				out var parent);
+
+			Assert.Equal(0, element.InvalidateMeasureCount);
+			Assert.Equal(1, parent.ComputeConstraintCount);
+			Assert.Equal(1, parent.InvalidateMeasureCount);
+			AssertEvents(expectations.Events, 
+				(element, InvalidationTrigger.HorizontalOptionsChanged),
+				(parent, InvalidationTrigger.MeasureChanged));
+		}
+
+		[Fact]
+		public void VisualElementWhenVerticalOptionsChangesInvalidatesWithVerticalOptionsChanged()
+		{
+			var expectations = TestMeasureInvalidation(
+				(view, parentView) =>
+				{
+					view.VerticalOptions = LayoutOptions.Center;
+				},
+				out var element,
+				out var parent);
+
+			Assert.Equal(0, element.InvalidateMeasureCount);
+			Assert.Equal(1, parent.ComputeConstraintCount);
+			Assert.Equal(1, parent.InvalidateMeasureCount);
+			AssertEvents(expectations.Events, 
+				(element, InvalidationTrigger.VerticalOptionsChanged),
+				(parent, InvalidationTrigger.MeasureChanged));
+		}
+
+		[Fact]
+		public void VisualElementWhenNotApplyingBindingsTriggerMultipleInvalidations()
+		{
+			var expectations = TestMeasureInvalidation(
+				(view, parentView) =>
+				{
+					view.HeightRequest = 100;
+					view.HorizontalOptions = LayoutOptions.Center;
+				},
+				out var element,
+				out var parent);
+
+			Assert.Equal(1, element.InvalidateMeasureCount);
+			Assert.Equal(1, parent.ComputeConstraintCount);
+			Assert.Equal(1, parent.InvalidateMeasureCount);
+			AssertEvents(expectations.Events,
+				(element, InvalidationTrigger.SizeRequestChanged),
+				(parent, InvalidationTrigger.MeasureChanged),
+				(element, InvalidationTrigger.HorizontalOptionsChanged),
+				(parent, InvalidationTrigger.MeasureChanged));
+		}
+
+		[Fact]
+		public void VisualElementWhenApplyingBindingsTriggerSingleInvalidation()
+		{
+			var expectations = TestMeasureInvalidation(
+				(view, parentView) =>
+				{
+					view.SetBinding(VisualElement.HeightRequestProperty, new Binding("HeightRequest"));
+					view.SetBinding(View.HorizontalOptionsProperty, new Binding("HorizontalOptions"));
+					view.BindingContext = new { HeightRequest = 100, HorizontalOptions = LayoutOptions.Center };
+				},
+				out var element,
+				out var parent);
+
+			Assert.Equal(1, element.InvalidateMeasureCount);
+			Assert.Equal(1, parent.ComputeConstraintCount);
+			Assert.Equal(0, parent.InvalidateMeasureCount);
+			AssertEvents(expectations.Events,
+				(element, InvalidationTrigger.SizeRequestChanged),
+				(parent, InvalidationTrigger.MeasureChanged));
+		}
+
+		[Fact]
+		public void VisualElementWhenPropagatingBindingsTriggerSingleInvalidation()
+		{
+			var expectations = TestMeasureInvalidation(
+				(view, parentView) =>
+				{
+					view.SetBinding(VisualElement.HeightRequestProperty, new Binding("HeightRequest"));
+					view.SetBinding(View.HorizontalOptionsProperty, new Binding("HorizontalOptions"));
+					parentView.BindingContext = new { HeightRequest = 100, HorizontalOptions = LayoutOptions.Center };
+				},
+				out var element,
+				out var parent);
+
+			Assert.Equal(1, element.InvalidateMeasureCount);
+			Assert.Equal(1, parent.ComputeConstraintCount);
+			Assert.Equal(0, parent.InvalidateMeasureCount);
+			AssertEvents(expectations.Events,
+				(element, InvalidationTrigger.SizeRequestChanged),
+				(parent, InvalidationTrigger.MeasureChanged));
+		}
+
+		[Fact]
+		public void VisualElementWhenPropagatingBindingsTriggerSingleInvalidationOnParent()
+		{
+			var expectations = TestMeasureInvalidation(
+				(view, parentView) =>
+				{
+					view.SetBinding(View.MarginProperty, new Binding("Margin"));
+					view.SetBinding(View.HorizontalOptionsProperty, new Binding("HorizontalOptions"));
+					parentView.BindingContext = new { Margin = 10, HorizontalOptions = LayoutOptions.Center };
+				},
+				out var element,
+				out var parent);
+
+			Assert.Equal(0, element.InvalidateMeasureCount);
+			Assert.Equal(1, parent.ComputeConstraintCount);
+			Assert.Equal(1, parent.InvalidateMeasureCount);
+			AssertEvents(expectations.Events,
+				(element, InvalidationTrigger.MarginChanged),
+				(parent, InvalidationTrigger.MeasureChanged));
+		}
+
+		[Fact]
+		public void VisualElementWhenApplyingAndPropagatingBindingsTriggerSingleInvalidationOnParent()
+		{
+			var expectations = TestMeasureInvalidation(
+				(view, parentView) =>
+				{
+					parentView.SetBinding(VisualElement.WidthRequestProperty, new Binding("WidthRequest"));
+					view.SetBinding(VisualElement.HeightRequestProperty, new Binding("HeightRequest"));
+					view.SetBinding(View.HorizontalOptionsProperty, new Binding("HorizontalOptions"));
+					parentView.BindingContext = new { WidthRequest = 10, HeightRequest = 100, HorizontalOptions = LayoutOptions.Center };
+				},
+				out var element,
+				out var parent);
+
+			Assert.Equal(1, element.InvalidateMeasureCount);
+			Assert.Equal(2, parent.ComputeConstraintCount); // setting WidthRequest on parent triggers children constraint computation
+			Assert.Equal(1, parent.InvalidateMeasureCount);
+			AssertEvents(expectations.Events,
+				(element, InvalidationTrigger.SizeRequestChanged),
+				(parent, InvalidationTrigger.SizeRequestChanged));
+		}
+
+		static MeasureInvalidatedExpectations TestMeasureInvalidation(
+			Action<ButtonStub, LayoutStub> act,
+			out ButtonStub element,
+			out LayoutStub parent)
+		{
+			// Arrange
+			element = new ButtonStub();
+			parent = new LayoutStub
+			{
+				element
+			};
+			parent.Handler = new HandlerStub();
+			element.Handler = new HandlerStub();
+
+			// reset counters
+			parent.ComputeConstraintCount = 0;
+			parent.InvalidateMeasureCount = 0;
+			element.InvalidateMeasureCount = 0;
+
+			var events = new List<(View Target, InvalidationTrigger Trigger)>();
+			element.MeasureInvalidated += (s, e) => events.Add(((View)s, ((InvalidationEventArgs)e).Trigger));
+			parent.MeasureInvalidated += (s, e) => events.Add(((View)s, ((InvalidationEventArgs)e).Trigger));
+
+			// Act
+			act(element, parent);
+
+			return new MeasureInvalidatedExpectations { Events = events };
+		}
+
+		private static void AssertEvents(IEnumerable<(View Target, InvalidationTrigger Trigger)> actualEvents, params (View Target, InvalidationTrigger Trigger)[] expectedEvents)
+		{
+			Assert.Equal(expectedEvents, actualEvents);
+		}
+
+		class LayoutStub : VerticalStackLayout
+		{
+			public int ComputeConstraintCount { get; set; }
+			public int InvalidateMeasureCount { get; set; }
+
+			internal override void ComputeConstraintForView(View view)
+			{
+				base.ComputeConstraintForView(view);
+				++ComputeConstraintCount;
+			}
+
+			protected override void InvalidateMeasureOverride()
+			{
+				base.InvalidateMeasureOverride();
+				++InvalidateMeasureCount;
+			}
+		}
+
+		class ButtonStub : Button
+		{
+			public int InvalidateMeasureCount { get; set; }
+			
+			protected override void InvalidateMeasureOverride()
+			{
+				base.InvalidateMeasureOverride();
+				++InvalidateMeasureCount;
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Controls/tests/Core.UnitTests/StackLayoutUnitTests.cs b/src/Controls/tests/Core.UnitTests/StackLayoutUnitTests.cs
index b2959c29cb46..8867788476ad 100644
--- a/src/Controls/tests/Core.UnitTests/StackLayoutUnitTests.cs
+++ b/src/Controls/tests/Core.UnitTests/StackLayoutUnitTests.cs
@@ -352,8 +352,7 @@ public void TestVisibility()
 
 			child1.IsVisible = false;
 
-			// Verify that the visibility change invalidated the layout, and simulate a native layout update 
-			AssertInvalidated(handler);
+			// Simulate a native layout update 
 			stack.ForceLayout();
 
 			Assert.False(child1.IsVisible);
@@ -668,7 +667,6 @@ public void PaddingResizeTest()
 			innerStack.Padding = new Thickness(30);
 
 			// Verify that the Padding change invalidated the layout, and simulate a native layout update 
-			AssertInvalidated(handler);
 			outerLayout.ForceLayout();
 
 			var afterSize = innerStack.Bounds.Size;
diff --git a/src/Controls/tests/Core.UnitTests/ViewUnitTests.cs b/src/Controls/tests/Core.UnitTests/ViewUnitTests.cs
index 186e0373ba83..ec504ba48c9c 100644
--- a/src/Controls/tests/Core.UnitTests/ViewUnitTests.cs
+++ b/src/Controls/tests/Core.UnitTests/ViewUnitTests.cs
@@ -88,7 +88,7 @@ public void TestOpacityClamping()
 		[Fact]
 		public void TestMeasureInvalidatedFiredOnVisibilityChanged()
 		{
-			var view = new View { IsVisible = false };
+			var view = new View { IsVisible = false, IsPlatformEnabled = true };
 			bool signaled = false;
 			view.MeasureInvalidated += (sender, e) =>
 			{
@@ -159,7 +159,7 @@ public async Task ScaleTo()
 		[Fact]
 		public void TestPlatformSizeChanged()
 		{
-			var view = new View();
+			var view = new View { IsPlatformEnabled = true };
 
 			bool sizeChanged = false;
 			view.MeasureInvalidated += (sender, args) => sizeChanged = true;
@@ -468,7 +468,7 @@ public void TestUnFocusedEvent()
 		[Fact]
 		public void MinimumWidthRequest()
 		{
-			var view = new View();
+			var view = new View { IsPlatformEnabled = true };
 
 			bool signaled = false;
 			view.MeasureInvalidated += (sender, args) => signaled = true;
@@ -485,7 +485,7 @@ public void MinimumWidthRequest()
 		[Fact]
 		public void MinimumHeightRequest()
 		{
-			var view = new View();
+			var view = new View { IsPlatformEnabled = true };
 
 			bool signaled = false;
 			view.MeasureInvalidated += (sender, args) => signaled = true;
diff --git a/src/Controls/tests/DeviceTests/Elements/CarouselView/CarouselViewTests.cs b/src/Controls/tests/DeviceTests/Elements/CarouselView/CarouselViewTests.cs
index 17c0b297ec30..35d046a8d77a 100644
--- a/src/Controls/tests/DeviceTests/Elements/CarouselView/CarouselViewTests.cs
+++ b/src/Controls/tests/DeviceTests/Elements/CarouselView/CarouselViewTests.cs
@@ -145,9 +145,9 @@ await CreateHandlerAndAddToWindow<CarouselViewHandler>(carouselView, async (hand
 				await Task.Delay(100);
 				Assert.NotNull(handler.PlatformView);
 				Assert.False(data.IsCollectionChangedEventEmpty);
+				((IElementHandler)handler).DisconnectHandler();
 			});
 
-			carouselView.Handler?.DisconnectHandler();
 
 			Assert.True(data.IsCollectionChangedEventEmpty);
 		}
diff --git a/src/Controls/tests/DeviceTests/Elements/View/ViewTests.cs b/src/Controls/tests/DeviceTests/Elements/View/ViewTests.cs
index c1b44e6c22c0..23750faca8d7 100644
--- a/src/Controls/tests/DeviceTests/Elements/View/ViewTests.cs
+++ b/src/Controls/tests/DeviceTests/Elements/View/ViewTests.cs
@@ -52,7 +52,7 @@ public async Task ViewWithMarginSetsFrameAndDesiredSizeCorrectly(Type controlTyp
 
 			await AttachAndRun<LayoutHandler>(layout, async (_) =>
 			{
-				await Task.Yield();
+				await Task.Delay(100);
 
 				var frame = control.Frame;
 				var desiredSize = control.DesiredSize;
@@ -65,6 +65,17 @@ await AttachAndRun<LayoutHandler>(layout, async (_) =>
 				Assert.Equal(55, frame.Bottom, 0.5d);
 				Assert.Equal(60, desiredSize.Width, 0.5d);
 				Assert.Equal(60, desiredSize.Height, 0.5d);
+
+				control.WidthRequest = 60;
+				
+				await Task.Delay(100);
+				
+				frame = control.Frame;
+				desiredSize = control.DesiredSize;
+				Assert.Equal(5, frame.X, 0.5d);
+				Assert.Equal(60, frame.Width, 0.5d);
+				Assert.Equal(65, frame.Right, 0.5d);
+				Assert.Equal(70, desiredSize.Width, 0.5d);
 			});
 		}
 	}
diff --git a/src/Core/src/Platform/iOS/IPropagatesSetNeedsLayout.cs b/src/Core/src/Platform/iOS/IPropagatesSetNeedsLayout.cs
new file mode 100644
index 000000000000..c68e19c61bfa
--- /dev/null
+++ b/src/Core/src/Platform/iOS/IPropagatesSetNeedsLayout.cs
@@ -0,0 +1,7 @@
+namespace Microsoft.Maui.Platform
+{
+	/// <summary>
+	/// Marks a <see cref="UIKit.UIView"/> that propagates <see cref="UIKit.UIView.SetNeedsLayout"/> to its parent.
+	/// </summary>
+	internal interface IPropagatesSetNeedsLayout;
+}
\ No newline at end of file
diff --git a/src/Core/src/Platform/iOS/MauiScrollView.cs b/src/Core/src/Platform/iOS/MauiScrollView.cs
index 00c1ca3d55e8..15412a70df8a 100644
--- a/src/Core/src/Platform/iOS/MauiScrollView.cs
+++ b/src/Core/src/Platform/iOS/MauiScrollView.cs
@@ -5,11 +5,10 @@
 
 namespace Microsoft.Maui.Platform
 {
-	public class MauiScrollView : UIScrollView, IUIViewLifeCycleEvents
+	public class MauiScrollView : UIScrollView, IUIViewLifeCycleEvents, IPropagatesSetNeedsLayout
 	{
-		public MauiScrollView()
-		{
-		}
+		bool _isSettingNeedsLayout;
+		bool _fireSetNeedsLayoutOnParentWhenWindowAttached;
 
 		// overriding this method so it does not automatically scroll large UITextFields
 		// while the KeyboardAutoManagerScroll is scrolling.
@@ -19,6 +18,45 @@ public override void ScrollRectToVisible(CGRect rect, bool animated)
 				base.ScrollRectToVisible(rect, animated);
 		}
 
+		public override void SetNeedsLayout()
+		{
+			if (_isSettingNeedsLayout)
+			{
+				return;
+			}
+
+			_isSettingNeedsLayout = true;
+			// If the content container is set, we need to invalidate that too
+			if (Subviews.Length > 0 && Subviews[0] is ContentView contentContainer)
+			{
+				contentContainer.SetNeedsLayout();
+			}
+			_isSettingNeedsLayout = false;
+
+			base.SetNeedsLayout();
+			TryToInvalidateSuperView(false);
+		}
+
+		private void TryToInvalidateSuperView(bool shouldOnlyInvalidateIfPending)
+		{
+			if (shouldOnlyInvalidateIfPending && !_fireSetNeedsLayoutOnParentWhenWindowAttached)
+			{
+				return;
+			}
+
+			// We check for Window to avoid scenarios where an invalidate might propagate up the tree
+			// To a SuperView that's been disposed which will cause a crash when trying to access it
+			if (Window is not null)
+			{
+				this.Superview?.SetNeedsLayout();
+				_fireSetNeedsLayoutOnParentWhenWindowAttached = false;
+			}
+			else
+			{
+				_fireSetNeedsLayoutOnParentWhenWindowAttached = true;
+			}
+		}
+
 		[UnconditionalSuppressMessage("Memory", "MEM0002", Justification = IUIViewLifeCycleEvents.UnconditionalSuppressMessage)]
 		EventHandler? _movedToWindow;
 		event EventHandler IUIViewLifeCycleEvents.MovedToWindow
@@ -31,6 +69,7 @@ public override void MovedToWindow()
 		{
 			base.MovedToWindow();
 			_movedToWindow?.Invoke(this, EventArgs.Empty);
+			TryToInvalidateSuperView(true);
 		}
 	}
 }
diff --git a/src/Core/src/Platform/iOS/MauiView.cs b/src/Core/src/Platform/iOS/MauiView.cs
index ebc05dd871f0..442e9abc6cbc 100644
--- a/src/Core/src/Platform/iOS/MauiView.cs
+++ b/src/Core/src/Platform/iOS/MauiView.cs
@@ -7,7 +7,7 @@
 
 namespace Microsoft.Maui.Platform
 {
-	public abstract class MauiView : UIView, ICrossPlatformLayoutBacking, IVisualTreeElementProvidable, IUIViewLifeCycleEvents
+	public abstract class MauiView : UIView, ICrossPlatformLayoutBacking, IVisualTreeElementProvidable, IUIViewLifeCycleEvents, IPropagatesSetNeedsLayout
 	{
 		bool _fireSetNeedsLayoutOnParentWhenWindowAttached;
 		static bool? _respondsToSafeArea;
diff --git a/src/Core/src/Platform/iOS/ViewExtensions.cs b/src/Core/src/Platform/iOS/ViewExtensions.cs
index fbb27d784684..7e89f47145b7 100644
--- a/src/Core/src/Platform/iOS/ViewExtensions.cs
+++ b/src/Core/src/Platform/iOS/ViewExtensions.cs
@@ -284,8 +284,7 @@ public static void InvalidateMeasure(this UIView platformView, IView view)
 		{
 			platformView.SetNeedsLayout();
 
-			// MauiView/WrapperView already propagates the SetNeedsLayout to the parent
-			if (platformView is not MauiView && platformView is not WrapperView)
+			if (platformView is not IPropagatesSetNeedsLayout)
 			{
 				platformView.Superview?.SetNeedsLayout();
 			}
diff --git a/src/Core/src/Platform/iOS/WrapperView.cs b/src/Core/src/Platform/iOS/WrapperView.cs
index 8660e9db8ea9..2e9be087aef6 100644
--- a/src/Core/src/Platform/iOS/WrapperView.cs
+++ b/src/Core/src/Platform/iOS/WrapperView.cs
@@ -9,7 +9,7 @@
 
 namespace Microsoft.Maui.Platform
 {
-	public partial class WrapperView : UIView, IDisposable, IUIViewLifeCycleEvents
+	public partial class WrapperView : UIView, IDisposable, IUIViewLifeCycleEvents, IPropagatesSetNeedsLayout
 	{
 		bool _fireSetNeedsLayoutOnParentWhenWindowAttached;
 		WeakReference<ICrossPlatformLayout>? _crossPlatformLayoutReference;
diff --git a/src/Core/src/PublicAPI/net-ios/PublicAPI.Unshipped.txt b/src/Core/src/PublicAPI/net-ios/PublicAPI.Unshipped.txt
index b0ccc5266a37..5a712dc90e6d 100644
--- a/src/Core/src/PublicAPI/net-ios/PublicAPI.Unshipped.txt
+++ b/src/Core/src/PublicAPI/net-ios/PublicAPI.Unshipped.txt
@@ -1,3 +1,4 @@
 #nullable enable
 override Microsoft.Maui.Platform.MauiCALayer.AddAnimation(CoreAnimation.CAAnimation! animation, string? key) -> void
-*REMOVED*override Microsoft.Maui.Handlers.BorderHandler.ConnectHandler(Microsoft.Maui.Platform.ContentView! platformView) -> void
\ No newline at end of file
+*REMOVED*override Microsoft.Maui.Handlers.BorderHandler.ConnectHandler(Microsoft.Maui.Platform.ContentView! platformView) -> void
+override Microsoft.Maui.Platform.MauiScrollView.SetNeedsLayout() -> void
diff --git a/src/Core/src/PublicAPI/net-maccatalyst/PublicAPI.Unshipped.txt b/src/Core/src/PublicAPI/net-maccatalyst/PublicAPI.Unshipped.txt
index 68239b19929e..5a712dc90e6d 100644
--- a/src/Core/src/PublicAPI/net-maccatalyst/PublicAPI.Unshipped.txt
+++ b/src/Core/src/PublicAPI/net-maccatalyst/PublicAPI.Unshipped.txt
@@ -1,3 +1,4 @@
 #nullable enable
 override Microsoft.Maui.Platform.MauiCALayer.AddAnimation(CoreAnimation.CAAnimation! animation, string? key) -> void
 *REMOVED*override Microsoft.Maui.Handlers.BorderHandler.ConnectHandler(Microsoft.Maui.Platform.ContentView! platformView) -> void
+override Microsoft.Maui.Platform.MauiScrollView.SetNeedsLayout() -> void