[2025/06/23] Candidate - In Flight Branch

eng/Versions.props

@@ -62,7 +62,7 @@
     <MicrosoftNETWorkloadEmscriptenCurrentManifest90100TransportVersion>9.0.5</MicrosoftNETWorkloadEmscriptenCurrentManifest90100TransportVersion>
     <MicrosoftNETWorkloadEmscriptenPackageVersion>$(MicrosoftNETWorkloadEmscriptenCurrentManifest90100TransportVersion)</MicrosoftNETWorkloadEmscriptenPackageVersion>
     <!-- wasdk -->
-    <MicrosoftWindowsAppSDKPackageVersion>1.7.250513003</MicrosoftWindowsAppSDKPackageVersion>
+    <MicrosoftWindowsAppSDKPackageVersion>1.7.250606001</MicrosoftWindowsAppSDKPackageVersion>
     <MicrosoftWindowsSDKBuildToolsPackageVersion>10.0.22621.756</MicrosoftWindowsSDKBuildToolsPackageVersion>
     <MicrosoftGraphicsWin2DPackageVersion>1.3.2</MicrosoftGraphicsWin2DPackageVersion>
     <MicrosoftWindowsWebView2PackageVersion>1.0.3179.45</MicrosoftWindowsWebView2PackageVersion>

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

@@ -616,5 +616,7 @@ private protected override string GetDebuggerDisplay()
 			var commandText = DebuggerDisplayHelpers.GetDebugText(nameof(Command), Command, false);
 			return $"{base.GetDebuggerDisplay()}, {textString}, {commandText}";
 		}
+
+		WeakCommandSubscription ICommandElement.CleanupTracker { get; set; }
 	}
 }

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

@@ -1,42 +1,27 @@
 #nullable disable
 using System;
 using System.Windows.Input;
+using Microsoft.Maui.Controls.Internals;
 using Microsoft.Maui.Graphics;
 
 namespace Microsoft.Maui.Controls
 {
 	/// <include file="../../../docs/Microsoft.Maui.Controls/TextCell.xml" path="Type[@FullName='Microsoft.Maui.Controls.TextCell']/Docs/*" />
-	public class TextCell : Cell
+	public class TextCell : Cell, ICommandElement
 	{
 		/// <summary>Bindable property for <see cref="Command"/>.</summary>
-		public static readonly BindableProperty CommandProperty = BindableProperty.Create(nameof(Command), typeof(ICommand), typeof(TextCell), default(ICommand),
-			propertyChanging: (bindable, oldvalue, newvalue) =>
-			{
-				var textCell = (TextCell)bindable;
-				var oldcommand = (ICommand)oldvalue;
-				if (oldcommand != null)
-					oldcommand.CanExecuteChanged -= textCell.OnCommandCanExecuteChanged;
-			}, propertyChanged: (bindable, oldvalue, newvalue) =>
-			{
-				var textCell = (TextCell)bindable;
-				var newcommand = (ICommand)newvalue;
-				if (newcommand != null)
-				{
-					textCell.IsEnabled = newcommand.CanExecute(textCell.CommandParameter);
-					newcommand.CanExecuteChanged += textCell.OnCommandCanExecuteChanged;
-				}
-			});
+		public static readonly BindableProperty CommandProperty =
+			BindableProperty.Create(nameof(Command), typeof(ICommand), typeof(TextCell),
+			propertyChanging: CommandElement.OnCommandChanging,
+			propertyChanged: CommandElement.OnCommandChanged);
 
 		/// <summary>Bindable property for <see cref="CommandParameter"/>.</summary>
-		public static readonly BindableProperty CommandParameterProperty = BindableProperty.Create(nameof(CommandParameter), typeof(object), typeof(TextCell), default(object),
-			propertyChanged: (bindable, oldvalue, newvalue) =>
-			{
-				var textCell = (TextCell)bindable;
-				if (textCell.Command != null)
-				{
-					textCell.IsEnabled = textCell.Command.CanExecute(newvalue);
-				}
-			});
+		public static readonly BindableProperty CommandParameterProperty =
+			BindableProperty.Create(nameof(CommandParameter),
+				typeof(object),
+				typeof(TextCell),
+				null,
+				propertyChanged: CommandElement.OnCommandParameterChanged);
 
 		/// <summary>Bindable property for <see cref="Text"/>.</summary>
 		public static readonly BindableProperty TextProperty = BindableProperty.Create(nameof(Text), typeof(string), typeof(TextCell), default(string));
@@ -104,9 +89,14 @@ protected internal override void OnTapped()
 			Command?.Execute(CommandParameter);
 		}
 
-		void OnCommandCanExecuteChanged(object sender, EventArgs eventArgs)
+		void ICommandElement.CanExecuteChanged(object sender, EventArgs eventArgs)
 		{
+			if (Command is null)
+				return;
+
 			IsEnabled = Command.CanExecute(CommandParameter);
 		}
+
+		WeakCommandSubscription ICommandElement.CleanupTracker { get; set; }
 	}
 }

src/Controls/src/Core/ColumnDefinitionCollection.cs

@@ -1,4 +1,5 @@
 #nullable disable
+using System.Collections.Generic;
 namespace Microsoft.Maui.Controls
 {
 	/// <include file="../../docs/Microsoft.Maui.Controls/ColumnDefinitionCollection.xml" path="Type[@FullName='Microsoft.Maui.Controls.ColumnDefinitionCollection']/Docs/*" />
@@ -11,5 +12,9 @@ public ColumnDefinitionCollection() : base()
 		public ColumnDefinitionCollection(params ColumnDefinition[] definitions) : base(definitions)
 		{
 		}
+
+		internal ColumnDefinitionCollection(List<ColumnDefinition> definitions, bool copy) : base(definitions, copy)
+		{
+		}
 	}
 }

src/Controls/src/Core/ColumnDefinitionCollectionTypeConverter.cs

@@ -1,8 +1,10 @@
 #nullable disable
 using System;
+using System.Buffers;
+using System.Collections.Generic;
 using System.ComponentModel;
 using System.Globalization;
-using System.Linq;
+using System.Text;
 using Microsoft.Maui.Controls.Xaml;
 
 namespace Microsoft.Maui.Controls
@@ -19,28 +21,61 @@ public override bool CanConvertTo(ITypeDescriptorContext context, Type destinati
 
 		public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
 		{
-			var strValue = value?.ToString();
+			var strValue = value as string ?? value?.ToString()
+				?? throw new InvalidOperationException(string.Format("Cannot convert \"{0}\" into {1}", value, typeof(ColumnDefinitionCollection)));
 
-			if (strValue != null)
+			// fast path for no value or empty string
+			if (strValue.Length == 0)
+				return new ColumnDefinitionCollection();
+
+#if NET6_0_OR_GREATER
+			var unsplit = (ReadOnlySpan<char>)strValue;
+			var count = unsplit.Count(',') + 1;
+			var definitions = new List<ColumnDefinition>(count);
+			foreach (var range in unsplit.Split(','))
+			{
+				var length = GridLengthTypeConverter.ParseStringToGridLength(unsplit[range]);
+				definitions.Add(new ColumnDefinition(length));
+			}
+#else
+			var lengths = strValue.Split(',');
+			var count = lengths.Length;
+			var definitions = new List<ColumnDefinition>(count);
+			foreach (var lengthStr in lengths)
 			{
-				var lengths = strValue.Split(',');
-				var converter = new GridLengthTypeConverter();
-				var definitions = new ColumnDefinition[lengths.Length];
-				for (var i = 0; i < lengths.Length; i++)
-					definitions[i] = new ColumnDefinition { Width = (GridLength)converter.ConvertFromInvariantString(lengths[i]) };
-				return new ColumnDefinitionCollection(definitions);
+				var length = GridLengthTypeConverter.ParseStringToGridLength(lengthStr);
+				definitions.Add(new ColumnDefinition(length));
 			}
+#endif
 
-			throw new InvalidOperationException(string.Format("Cannot convert \"{0}\" into {1}", strValue, typeof(ColumnDefinitionCollection)));
+			return new ColumnDefinitionCollection(definitions, copy: false);
 		}
 
 
 		public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
 		{
-			if (value is not ColumnDefinitionCollection cdc)
+			if (value is not ColumnDefinitionCollection definitions)
 				throw new NotSupportedException();
-			var converter = new GridLengthTypeConverter();
-			return string.Join(", ", cdc.Select(cd => converter.ConvertToInvariantString(cd.Width)));
+
+			var count = definitions.Count;
+
+			// fast path for empty or single definitions
+			if (count == 0)
+				return string.Empty;
+			if (count == 1)
+				return GridLengthTypeConverter.ConvertToString(definitions[0].Width);
+
+			// for multiple items
+			var pool = ArrayPool<string>.Shared;
+			var rentedArray = pool.Rent(definitions.Count);
+			for (var i = 0; i < definitions.Count; i++)
+			{
+				var definition = definitions[i];
+				rentedArray[i] = GridLengthTypeConverter.ConvertToString(definition.Width);
+			}
+			var result = string.Join(", ", rentedArray, 0, definitions.Count);
+			pool.Return(rentedArray);
+			return result;
 		}
 	}
 }

src/Controls/src/Core/CommandElement.cs

@@ -10,15 +10,24 @@ static class CommandElement
 		public static void OnCommandChanging(BindableObject bo, object o, object n)
 		{
 			var commandElement = (ICommandElement)bo;
-			if (o is ICommand oldCommand)
-				oldCommand.CanExecuteChanged -= commandElement.CanExecuteChanged;
+			commandElement.CleanupTracker?.Dispose();
+			commandElement.CleanupTracker = null;
 		}
 
 		public static void OnCommandChanged(BindableObject bo, object o, object n)
 		{
 			var commandElement = (ICommandElement)bo;
-			if (n is ICommand newCommand)
-				newCommand.CanExecuteChanged += commandElement.CanExecuteChanged;
+
+			if (n is null)
+			{
+				commandElement.CleanupTracker?.Dispose();
+				commandElement.CleanupTracker = null;
+			}
+			else
+			{
+				commandElement.CleanupTracker = new WeakCommandSubscription(bo, (ICommand)n, commandElement.CanExecuteChanged);
+			}
+
 			commandElement.CanExecuteChanged(bo, EventArgs.Empty);
 		}
 
@@ -36,4 +45,4 @@ public static bool GetCanExecute(ICommandElement commandElement)
 			return commandElement.Command.CanExecute(commandElement.CommandParameter);
 		}
 	}
-}
+}

src/Controls/src/Core/Compatibility/Handlers/Shell/Android/ShellSearchView.cs

@@ -11,8 +11,8 @@
 using Android.Widget;
 using AndroidX.AppCompat.Widget;
 using AndroidX.CardView.Widget;
+using AndroidX.Core.Content;
 using Java.Lang;
-using Microsoft.Maui.Controls.Platform.Compatibility;
 using AColor = Android.Graphics.Color;
 using AImageButton = Android.Widget.ImageButton;
 using ASupportDrawable = AndroidX.AppCompat.Graphics.Drawable;
@@ -317,12 +317,22 @@ AImageButton CreateImageButton(Context context, BindableObject bindable, Bindabl
 			result.SetScaleType(ImageView.ScaleType.FitCenter);
 
 			if (bindable.GetValue(property) is ImageSource image)
+			{
 				AutomationPropertiesProvider.SetContentDescription(result, image, null, null);
 
-			((ImageSource)bindable.GetValue(property)).LoadImage(MauiContext, (r) =>
+				image.LoadImage(MauiContext, (r) =>
+				{
+					result.SetImageDrawable(r?.Value);
+				});
+			}
+			else if (defaultImage > 0 && ContextCompat.GetDrawable(Context, defaultImage) is Drawable defaultDrawable)
 			{
-				result.SetImageDrawable(r?.Value);
-			});
+				result.SetImageDrawable(defaultDrawable);
+			}
+			else
+			{
+				result.SetImageDrawable(null);
+			}
 
 			var lp = new LinearLayout.LayoutParams((int)Context.ToPixels(22), LP.MatchParent)
 			{

src/Controls/src/Core/DefinitionCollection.cs

@@ -14,6 +14,8 @@ public class DefinitionCollection<T> : IList<T>, ICollection<T> where T : IDefin
 
 		internal DefinitionCollection(params T[] items) => _internalList = new List<T>(items);
 
+		internal DefinitionCollection(List<T> items, bool copy) => _internalList = copy ? new List<T>(items) : items;
+
 		public void Add(T item)
 		{
 			_internalList.Add(item);

src/Controls/src/Core/DepdendentHandle.cs

@@ -0,0 +1,96 @@
+#nullable enable
+
+#if NETSTANDARD2_0 || NETSTANDARD2_1
+using System;
+using System.Runtime;
+using System.Runtime.CompilerServices;
+using System.Windows.Input;
+
+namespace System.Runtime;
+
+/// <summary>
+/// A wrapper around ConditionalWeakTable that replicates DependentHandle behavior.
+/// Creates a dependency between a primary object and a dependent object where
+/// the dependent object becomes eligible for collection when the primary is collected.
+/// </summary>
+internal class DependentHandle : IDisposable
+{
+	private readonly ConditionalWeakTable<object, object> _table;
+	private readonly WeakReference<object> _primaryRef;
+	private bool _disposed;
+
+	/// <summary>
+	/// Initializes a new instance of DependentHandle with a primary and dependent object.
+	/// </summary>
+	/// <param name="primary">The primary object that controls the lifetime of the dependent object.</param>
+	/// <param name="dependent">The dependent object that will be collected when primary is collected.</param>
+	public DependentHandle(object primary, object? dependent)
+	{
+		_table = new ConditionalWeakTable<object, object>();
+		_primaryRef = new WeakReference<object>(primary);
+
+		// Store the dependent object in the table, keyed by the primary object
+		if (dependent is not null)
+		{
+			_table.Add(primary, dependent);
+		}
+	}
+
+	/// <summary>
+	/// Gets the primary object if it's still alive, otherwise returns null.
+	/// </summary>
+	public object? Target
+	{
+		get
+		{
+			if (_disposed)
+				return null;
+
+			return _primaryRef.TryGetTarget(out var target) ? target : null;
+		}
+	}
+
+	/// <summary>
+	/// Gets the dependent object if the primary object is still alive, otherwise returns null.
+	/// </summary>
+	public object? Dependent
+	{
+		get
+		{
+			if (_disposed)
+				return null;
+
+			if (_primaryRef.TryGetTarget(out var primary) &&
+				_table.TryGetValue(primary, out var dependent))
+			{
+				return dependent;
+			}
+
+			return null;
+		}
+	}
+
+	/// <summary>
+	/// Checks if both primary and dependent objects are still alive.
+	/// </summary>
+	public bool IsAllocated => Target is not null && Dependent is not null;
+
+	/// <summary>
+	/// Disposes the DependentHandleCWT, clearing all references.
+	/// </summary>
+	public void Dispose()
+	{
+		if (_disposed)
+			return;
+
+		_disposed = true;
+
+		// Clear the table - this will allow dependent objects to be collected
+		// even if the primary object is still alive
+		if (_primaryRef.TryGetTarget(out var primary))
+		{
+			_table.Remove(primary);
+		}
+	}
+}
+#endif