[leak-fix] Fix GradientBrush.GradientStops memory leak (Fixes #36363)

src/Controls/src/Core/BindingBase.cs

@@ -100,7 +100,15 @@ public object FallbackValue
 
 		internal bool AllowChaining { get; set; }
 
-		internal object Context { get; set; }
+		object _context;
+
+		internal object Context
+		{
+			get => _context is BindableObject.InheritedBindingContextReference inheritedContext
+				? inheritedContext.Target
+				: _context;
+			set => _context = value;
+		}
 
 		internal bool IsApplied { get; private set; }
 

src/Controls/src/Core/DispatcherExtensions.cs

@@ -9,42 +9,65 @@ namespace Microsoft.Maui.Controls
 	internal static class DispatcherExtensions
 	{
 		public static IDispatcher FindDispatcher(this BindableObject? bindableObject)
+		{
+			if (bindableObject.TryFindDispatcher(includeParents: true) is IDispatcher dispatcher)
+				return dispatcher;
+
+			if (bindableObject is not Application &&
+				Application.Current?.Dispatcher is IDispatcher appDispatcher)
+			{
+				return appDispatcher;
+			}
+
+			throw new InvalidOperationException("BindableObject was not instantiated on a thread with a dispatcher nor does the current application have a dispatcher.");
+		}
+
+		internal static IDispatcher? TryFindDispatcher(
+			this BindableObject? bindableObject,
+			bool includeParents)
 		{
 			// try find the dispatcher in the current hierarchy
 			// Exclude Application because we don't want to jump
 			// directly to the Application IDispatcher at this point
 			if (bindableObject is not Application &&
-				bindableObject is Element element &&
-				element.FindMauiContext() is IMauiContext context &&
-				context.Services.GetService<IDispatcher>() is IDispatcher handlerDispatcher)
-				return handlerDispatcher;
+				bindableObject is Element element)
+			{
+				var context = includeParents
+					? element.FindMauiContext()
+					: (element as Maui.IElement)?.Handler?.MauiContext;
+
+				if (context?.Services.GetService<IDispatcher>() is IDispatcher handlerDispatcher)
+					return handlerDispatcher;
+			}
 
 			// maybe this thread has a dispatcher
 			if (Dispatcher.GetForCurrentThread() is IDispatcher globalDispatcher)
 				return globalDispatcher;
 
 			// If BO is of type Application then return the Dispatcher from ApplicationDispatcher
 			if (bindableObject is Application app &&
-				app.FindMauiContext() is IMauiContext appMauiContext)
-			{
-				if (appMauiContext.Services.GetOptionalApplicationDispatcher() is IDispatcher appDispatcherServiceDispatcher)
-					return appDispatcherServiceDispatcher;
+				TryFindApplicationDispatcher(app) is IDispatcher appDispatcher)
+				return appDispatcher;
 
-				// If BO is of type Application then check for its Dispatcher
-				if (appMauiContext.Services.GetService<IDispatcher>() is IDispatcher appHandlerDispatcher)
-					return appHandlerDispatcher;
+			// Try the static app's registered dispatcher without calling its Dispatcher
+			// property, which may throw. The public FindDispatcher path preserves that
+			// fallback after this non-throwing lookup returns null.
+			if (bindableObject is not Application && Application.Current is Application currentApp)
+			{
+				if (TryFindApplicationDispatcher(currentApp) is IDispatcher currentAppDispatcherService)
+					return currentAppDispatcherService;
 			}
 
-			// try looking on the static app
-			// We don't include Application because Application.Dispatcher will call
-			// `FindDispatcher` if it's _dispatcher property isn't initialized so this
-			// could cause a Stack Overflow Exception
-			if (bindableObject is not Application &&
-				Application.Current?.Dispatcher is IDispatcher appDispatcher)
-				return appDispatcher;
+			return null;
+		}
 
-			// no dispatchers found at all
-			throw new InvalidOperationException("BindableObject was not instantiated on a thread with a dispatcher nor does the current application have a dispatcher.");
+		static IDispatcher? TryFindApplicationDispatcher(Application app)
+		{
+			if (app.FindMauiContext() is not IMauiContext appMauiContext)
+				return null;
+
+			return appMauiContext.Services.GetOptionalApplicationDispatcher()
+				?? appMauiContext.Services.GetService<IDispatcher>();
 		}
 
 		public static void DispatchIfRequired(this IDispatcher? dispatcher, Action action)

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

@@ -6,10 +6,12 @@
 using System.ComponentModel;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using System.Threading;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Maui.Controls.Hosting;
 using Microsoft.Maui.Controls.Internals;
+using Microsoft.Maui.Dispatching;
 
 namespace Microsoft.Maui.Controls
 {
@@ -333,32 +335,80 @@ internal Element ParentOverride
 		}
 
 		WeakReference<Element> _realParent;
-		Element TryGetRealParent(bool logWarningIfParentHasBeenCollected = true)
+		Element TryGetRealParent(
+			bool logWarningIfParentHasBeenCollected = true,
+			bool clearInheritedContextIfDispatchNotRequired = true)
 		{
-			var realParent = _realParent;
-			if (realParent is null)
+			while (true)
 			{
-				return null;
-			}
-			if (realParent.TryGetTarget(out var parent))
-			{
-				return parent;
-			}
-			else
-			{
-				// Clear the weak reference since the target has been garbage collected
-				// This prevents repeated checks and warnings on subsequent accesses
-				_realParent = null;
+				var realParent = Volatile.Read(ref _realParent);
+				if (realParent is null)
+				{
+					if (clearInheritedContextIfDispatchNotRequired)
+					{
+						DispatchInheritedBindingContextCleanup(clearIfDispatchNotRequired: true);
+						if (Volatile.Read(ref _realParent) is not null)
+							continue;
+					}
+
+					return null;
+				}
+
+				if (realParent.TryGetTarget(out var parent))
+					return parent;
+
+				if (!ClearRealParentAndInheritedContextIfCollected(
+					realParent,
+					clearInheritedContextIfDispatchNotRequired))
+					continue;
+
 				if (logWarningIfParentHasBeenCollected)
 				{
 					Application.Current?
 										.FindMauiContext()?
 										.CreateLogger<Element>()?
 										.LogWarning($"The RealParent on {this} has been Garbage Collected. This should never happen. Please log a bug: https://github.com/dotnet/maui");
+					logWarningIfParentHasBeenCollected = false;
 				}
 			}
+		}
 
-			return null;
+		internal void ClearRealParentAndInheritedContextIfCollected()
+		{
+			var realParent = Volatile.Read(ref _realParent);
+			if (realParent is not null)
+				ClearRealParentAndInheritedContextIfCollected(
+					realParent,
+					clearInheritedContextIfDispatchNotRequired: false);
+		}
+
+		bool ClearRealParentAndInheritedContextIfCollected(
+			WeakReference<Element> realParent,
+			bool clearInheritedContextIfDispatchNotRequired)
+		{
+			if (realParent.TryGetTarget(out _))
+				return false;
+
+			// Only clear the reference we observed; a new parent may be assigned concurrently.
+			if (!ReferenceEquals(Interlocked.CompareExchange(ref _realParent, null, realParent), realParent))
+				return false;
+
+			if (Volatile.Read(ref _realParent) is not null)
+				return true;
+
+			var inheritedContext = MarkInheritedBindingContextForCleanup();
+			if (inheritedContext is null)
+				return true;
+
+			if (Volatile.Read(ref _realParent) is not null)
+			{
+				CancelInheritedBindingContextCleanup(inheritedContext);
+				return true;
+			}
+
+			DispatchInheritedBindingContextCleanup(clearInheritedContextIfDispatchNotRequired);
+
+			return true;
 		}
 
 		/// <summary>For internal use by .NET MAUI.</summary>
@@ -369,9 +419,9 @@ public Element RealParent
 			private set
 			{
 				if (value is null)
-					_realParent = null;
+					Volatile.Write(ref _realParent, null);
 				else
-					_realParent = new WeakReference<Element>(value);
+					Volatile.Write(ref _realParent, new WeakReference<Element>(value));
 			}
 		}
 
@@ -395,13 +445,22 @@ public Element Parent
 
 		void SetParent(Element value)
 		{
-			Element realParent = TryGetRealParent(false);
+			Element realParent = TryGetRealParent(
+				logWarningIfParentHasBeenCollected: false,
+				clearInheritedContextIfDispatchNotRequired: value is null);
 
 			if (realParent == value)
 			{
 				return;
 			}
 
+			if (!HasDispatcher && value is not null)
+			{
+				var parentDispatcher = value.GetDispatcherIfAvailable()
+					?? value.TryFindDispatcher(includeParents: true);
+				SetDispatcherIfUnset(parentDispatcher);
+			}
+
 			OnPropertyChanging(nameof(Parent));
 
 			if (_parentOverride == null)
@@ -420,12 +479,12 @@ void SetParent(Element value)
 			}
 
 			RealParent = value;
-			if (RealParent != null)
+			if (value != null)
 			{
 				var resources = GetParentResourcesForParentSet();
 				if (resources != null)
 					OnParentResourcesChanged(resources);
-				((IElementDefinition)RealParent).AddResourcesChangedListener(OnParentResourcesChanged);
+				((IElementDefinition)value).AddResourcesChangedListener(OnParentResourcesChanged);
 			}
 
 			object context = value?.BindingContext;
@@ -1086,6 +1145,9 @@ void SetHandler(IElementHandler newHandler)
 				OnHandlerChangingCore(new HandlerChangingEventArgs(_previousHandler, newHandler));
 
 				_handler = newHandler;
+				if (!HasDispatcher &&
+					_handler?.MauiContext?.Services.GetService<IDispatcher>() is IDispatcher handlerDispatcher)
+					SetDispatcherIfUnset(handlerDispatcher);
 
 				// Only call disconnect if the previous handler is still connected to this virtual view.
 				// If a handler is being reused for a different VirtualView then the virtual