From bd5698f9f033e5650c1455413b444685310776de Mon Sep 17 00:00:00 2001
From: Stephane Delcroix <stephane@delcroix.org>
Date: Thu, 27 Nov 2025 22:21:26 +0100
Subject: [PATCH 1/4] Add C# 14 extension property support for XAML

This PR adds support for C# 14 extension properties in XAML for both
setting properties and using them in binding sources.

## Changes

### Runtime Inflator (ApplyPropertiesVisitor.cs)
- Added FindExtensionPropertyMethods to search loaded assemblies
- Added TrySetExtensionProperty and TryGetExtensionProperty methods
- Modified TrySetProperty/TryGetProperty to fallback to extension properties

### XamlC Build Tasks (SetPropertiesVisitor.cs)
- Added FindExtensionPropertyMethods using Mono.Cecil
- Added CanSetExtensionProperty, SetExtensionProperty methods
- Added CanGetExtensionProperty, GetExtensionProperty methods
- Generates IL code to call static extension property getter/setter

### SourceGen (SetPropertyHelpers.cs, NodeSGExtensions.cs)
- Added FindExtensionPropertyMethods using Roslyn
- Added CanConvertTo overload for ITypeSymbol
- Added CanSetExtensionProperty and SetExtensionProperty methods
- Note: SourceGen support needs additional integration work

## Usage

Extension properties can now be set directly in XAML:
```xml
<Label MyTag="hello" MyPriority="42" />
```

And used in bindings:
```xml
<Label Text="{Binding Person.FullName}" />
```

Where FullName is a C# 14 extension property on PersonModel.

## Tests
- Added ExtensionProperties.rtxc.xaml tests for setting properties
- Added ExtensionPropertiesBinding.xaml tests for binding scenarios
- All 1778 XAML unit tests pass
- All 99 SourceGen unit tests pass
---
 .../src/Build.Tasks/SetPropertiesVisitor.cs   | 192 ++++++++++++
 .../src/SourceGen/NodeSGExtensions.cs         |   7 +
 .../src/SourceGen/SetPropertyHelpers.cs       | 225 ++++++++++++++
 .../src/Xaml/ApplyPropertiesVisitor.cs        | 174 ++++++++++-
 .../ExtensionProperties.rtxc.xaml             |  23 ++
 .../ExtensionProperties.xaml.cs               | 235 ++++++++++++++
 .../ExtensionPropertiesBinding.xaml           |  16 +
 .../ExtensionPropertiesBinding.xaml.cs        | 288 ++++++++++++++++++
 8 files changed, 1154 insertions(+), 6 deletions(-)
 create mode 100644 src/Controls/tests/Xaml.UnitTests/ExtensionProperties.rtxc.xaml
 create mode 100644 src/Controls/tests/Xaml.UnitTests/ExtensionProperties.xaml.cs
 create mode 100644 src/Controls/tests/Xaml.UnitTests/ExtensionPropertiesBinding.xaml
 create mode 100644 src/Controls/tests/Xaml.UnitTests/ExtensionPropertiesBinding.xaml.cs

diff --git a/src/Controls/src/Build.Tasks/SetPropertiesVisitor.cs b/src/Controls/src/Build.Tasks/SetPropertiesVisitor.cs
index 762a0358b393..30dd1131b933 100644
--- a/src/Controls/src/Build.Tasks/SetPropertiesVisitor.cs
+++ b/src/Controls/src/Build.Tasks/SetPropertiesVisitor.cs
@@ -1174,6 +1174,10 @@ public static IEnumerable<Instruction> SetPropertyValue(VariableDefinition paren
 			if (CanSet(parent, localName, valueNode, context))
 				return Set(parent, localName, valueNode, iXmlLineInfo, context);
 
+			//If it's a C# 14 extension property, set it
+			if (CanSetExtensionProperty(parent, localName, valueNode, context))
+				return SetExtensionProperty(parent, localName, valueNode, iXmlLineInfo, context);
+
 			//If it's an already initialized property, add to it
 			if (CanAdd(parent, propertyName, valueNode, iXmlLineInfo, context))
 				return Add(parent, propertyName, valueNode, iXmlLineInfo, context);
@@ -1195,6 +1199,10 @@ public static IEnumerable<Instruction> GetPropertyValue(VariableDefinition paren
 			if (CanGet(parent, localName, context, out _))
 				return Get(parent, localName, lineInfo, context, out propertyType);
 
+			//If it's a C# 14 extension property, get it
+			if (CanGetExtensionProperty(parent, localName, context, out _))
+				return GetExtensionProperty(parent, localName, lineInfo, context, out propertyType);
+
 			throw new BuildException(PropertyResolution, lineInfo, null, localName, parent.VariableType.FullName);
 		}
 
@@ -1667,6 +1675,190 @@ static IEnumerable<Instruction> Get(VariableDefinition parent, string localName,
 				];
 		}
 
+		/// <summary>
+		/// Finds C# 14 extension property getter and setter methods for a given target type and property name.
+		/// Extension properties are compiled as static get_X/set_X methods in extension container types
+		/// that have nested types marked with ExtensionAttribute.
+		/// </summary>
+		static (MethodDefinition Getter, MethodDefinition Setter, TypeReference DeclaringType) FindExtensionPropertyMethods(
+			TypeReference targetType, string propertyName, ILContext context)
+		{
+			var module = context.Body.Method.Module;
+			var cache = context.Cache;
+			var getterName = $"get_{propertyName}";
+			var setterName = $"set_{propertyName}";
+			var extensionAttributeFullName = "System.Runtime.CompilerServices.ExtensionAttribute";
+
+			// Get all assemblies to search
+			var assembliesToSearch = new List<AssemblyDefinition>();
+
+			// Add the current module's assembly
+			assembliesToSearch.Add(module.Assembly);
+
+			// Add all referenced assemblies
+			foreach (var asmRef in module.AssemblyReferences)
+			{
+				try
+				{
+					var asm = module.AssemblyResolver.Resolve(asmRef);
+					if (asm != null)
+						assembliesToSearch.Add(asm);
+				}
+				catch
+				{
+					// Skip assemblies that can't be resolved
+				}
+			}
+
+			foreach (var assembly in assembliesToSearch)
+			{
+				foreach (var asmModule in assembly.Modules)
+				{
+					foreach (var type in asmModule.Types)
+					{
+						// Extension containers must be static classes (abstract and sealed) with ExtensionAttribute
+						if (!type.IsAbstract || !type.IsSealed)
+							continue;
+
+						if (!type.CustomAttributes.Any(ca => ca.AttributeType.FullName == extensionAttributeFullName))
+							continue;
+
+						// Check if this container has nested types with ExtensionAttribute (C# 14 extension blocks)
+						var hasExtensionNestedTypes = type.NestedTypes.Any(nt =>
+							nt.CustomAttributes.Any(ca => ca.AttributeType.FullName == extensionAttributeFullName));
+
+						if (!hasExtensionNestedTypes)
+							continue;
+
+						// Look for get_PropertyName and set_PropertyName static methods
+						MethodDefinition getter = null;
+						MethodDefinition setter = null;
+
+						foreach (var method in type.Methods)
+						{
+							if (!method.IsStatic || !method.IsPublic)
+								continue;
+
+							if (method.Name == getterName && method.Parameters.Count == 1)
+							{
+								var paramType = method.Parameters[0].ParameterType;
+								if (IsAssignableFrom(paramType, targetType, cache))
+								{
+									getter = method;
+								}
+							}
+							else if (method.Name == setterName && method.Parameters.Count == 2)
+							{
+								var paramType = method.Parameters[0].ParameterType;
+								if (IsAssignableFrom(paramType, targetType, cache))
+								{
+									setter = method;
+								}
+							}
+						}
+
+						if (getter != null || setter != null)
+						{
+							return (getter, setter, module.ImportReference(type));
+						}
+					}
+				}
+			}
+
+			return (null, null, null);
+		}
+
+		static bool IsAssignableFrom(TypeReference baseType, TypeReference derivedType, XamlCache cache)
+		{
+			if (baseType.FullName == derivedType.FullName)
+				return true;
+
+			return derivedType.InheritsFromOrImplements(cache, baseType);
+		}
+
+		static bool CanSetExtensionProperty(VariableDefinition parent, string localName, INode node, ILContext context)
+		{
+			var (getter, setter, _) = FindExtensionPropertyMethods(parent.VariableType, localName, context);
+			if (setter == null)
+				return false;
+
+			// Get the property type from the getter's return type or setter's second parameter
+			var propertyType = getter?.ReturnType ?? setter.Parameters[1].ParameterType;
+			var module = context.Body.Method.Module;
+
+			if (node is ValueNode valueNode && valueNode.CanConvertValue(context, propertyType, [propertyType.ResolveCached(context.Cache)]))
+				return true;
+
+			if (node is not ElementNode elementNode)
+				return false;
+
+			var vardef = context.Variables[elementNode];
+			var implicitOperator = vardef.VariableType.GetImplicitOperatorTo(context.Cache, propertyType, module);
+
+			if (vardef.VariableType.InheritsFromOrImplements(context.Cache, propertyType))
+				return true;
+			if (implicitOperator != null)
+				return true;
+			if (propertyType.FullName == "System.Object")
+				return true;
+
+			return false;
+		}
+
+		static bool CanGetExtensionProperty(VariableDefinition parent, string localName, ILContext context, out TypeReference propertyType)
+		{
+			propertyType = null;
+			var (getter, _, _) = FindExtensionPropertyMethods(parent.VariableType, localName, context);
+			if (getter == null)
+				return false;
+
+			propertyType = context.Body.Method.Module.ImportReference(getter.ReturnType);
+			return true;
+		}
+
+		static IEnumerable<Instruction> SetExtensionProperty(VariableDefinition parent, string localName, INode node, IXmlLineInfo iXmlLineInfo, ILContext context)
+		{
+			var module = context.Body.Method.Module;
+			var (getter, setter, declaringType) = FindExtensionPropertyMethods(parent.VariableType, localName, context);
+
+			// Get the property type from the getter's return type or setter's second parameter
+			var propertyType = module.ImportReference(getter?.ReturnType ?? setter.Parameters[1].ParameterType);
+
+			var setterRef = module.ImportReference(setter);
+
+			// For static extension method: call ExtensionClass.set_PropertyName(target, value)
+			// Load the target object
+			yield return Create(Ldloc, parent);
+
+			if (node is ValueNode valueNode)
+			{
+				foreach (var instruction in valueNode.PushConvertedValue(context, propertyType, [propertyType.ResolveCached(context.Cache)], (requiredServices) => valueNode.PushServiceProvider(context, requiredServices, propertyRef: null), false, true))
+					yield return instruction;
+				yield return Create(Call, setterRef);
+			}
+			else if (node is ElementNode elementNode)
+			{
+				foreach (var instruction in context.Variables[elementNode].LoadAs(context.Cache, propertyType, module))
+					yield return instruction;
+				yield return Create(Call, setterRef);
+			}
+		}
+
+		static IEnumerable<Instruction> GetExtensionProperty(VariableDefinition parent, string localName, IXmlLineInfo iXmlLineInfo, ILContext context, out TypeReference propertyType)
+		{
+			var module = context.Body.Method.Module;
+			var (getter, _, declaringType) = FindExtensionPropertyMethods(parent.VariableType, localName, context);
+
+			var getterRef = module.ImportReference(getter);
+			propertyType = module.ImportReference(getter.ReturnType);
+
+			// For static extension method: call ExtensionClass.get_PropertyName(target)
+			return [
+				Create(Ldloc, parent),
+				Create(Call, getterRef),
+			];
+		}
+
 		static bool CanAdd(VariableDefinition parent, XmlName propertyName, INode valueNode, IXmlLineInfo lineInfo, ILContext context)
 		{
 			var module = context.Body.Method.Module;
diff --git a/src/Controls/src/SourceGen/NodeSGExtensions.cs b/src/Controls/src/SourceGen/NodeSGExtensions.cs
index 271cb304a2ff..2ec7cc88a2f3 100644
--- a/src/Controls/src/SourceGen/NodeSGExtensions.cs
+++ b/src/Controls/src/SourceGen/NodeSGExtensions.cs
@@ -160,6 +160,13 @@ .. property.Type.GetAttributes()
 	public static bool CanConvertTo(this ValueNode valueNode, IPropertySymbol property, SourceGenContext context)
 			=> CanConvertTo(valueNode, property, context, out _);
 
+	public static bool CanConvertTo(this ValueNode valueNode, ITypeSymbol toType, SourceGenContext context)
+	{
+		List<AttributeData> attributes = [.. toType.GetAttributes()];
+		var typeConverter = attributes.FirstOrDefault(ad => ad.AttributeClass?.ToString() == "System.ComponentModel.TypeConverterAttribute")?.ConstructorArguments[0].Value as ITypeSymbol;
+		return CanConvertTo(valueNode, toType, typeConverter, context);
+	}
+
 	public static bool CanConvertTo(this ValueNode valueNode, ITypeSymbol toType, ITypeSymbol? converter, SourceGenContext context)
 	{
 		var stringValue = (string)valueNode.Value;
diff --git a/src/Controls/src/SourceGen/SetPropertyHelpers.cs b/src/Controls/src/SourceGen/SetPropertyHelpers.cs
index a2c893990b53..d03cf7cd65af 100644
--- a/src/Controls/src/SourceGen/SetPropertyHelpers.cs
+++ b/src/Controls/src/SourceGen/SetPropertyHelpers.cs
@@ -65,6 +65,13 @@ public static void SetPropertyValue(IndentedTextWriter writer, ILocalValue paren
 			return;
 		}
 
+		//C# 14 extension property
+		if (!asCollectionItem && CanSetExtensionProperty(parentVar, localName, valueNode, context))
+		{
+			SetExtensionProperty(writer, parentVar, localName, valueNode, context, getNodeValue);
+			return;
+		}
+
 		if (CanAdd(parentVar, localName, bpFieldSymbol, attached, valueNode, context, getNodeValue))
 		{
 			Add(writer, parentVar, propertyName, valueNode, context, getNodeValue);
@@ -534,4 +541,222 @@ static void Add(IndentedTextWriter writer, ILocalValue parentVar, XmlName proper
 		using (context.ProjectItem.EnableLineInfo ? PrePost.NewLineInfo(writer, (IXmlLineInfo)valueNode, context.ProjectItem) : PrePost.NoBlock())
 			writer.WriteLine($"{parentObj}.Add(({itemType.ToFQDisplayString()}){cast}{getNodeValue(valueNode, context.Compilation.ObjectType).ValueAccessor});");
 	}
+
+	/// <summary>
+	/// Finds C# 14 extension property getter and setter methods for a given target type and property name.
+	/// Extension properties are compiled as static get_X/set_X methods in extension container types
+	/// that have nested types marked with ExtensionAttribute.
+	/// </summary>
+	static (IMethodSymbol? Getter, IMethodSymbol? Setter) FindExtensionPropertyMethods(
+		ITypeSymbol targetType, string propertyName, SourceGenContext context)
+	{
+		var getterName = $"get_{propertyName}";
+		var setterName = $"set_{propertyName}";
+		var extensionAttributeName = "global::System.Runtime.CompilerServices.ExtensionAttribute";
+
+		// Search all referenced assemblies and the current compilation
+		var allTypes = GetAllTypesFromCompilation(context.Compilation);
+
+		foreach (var type in allTypes)
+		{
+			// Extension containers must be static classes (abstract and sealed) with ExtensionAttribute
+			if (!type.IsStatic)
+				continue;
+
+			if (!type.GetAttributes().Any(a => a.AttributeClass?.ToFQDisplayString() == extensionAttributeName))
+				continue;
+
+			// Check if this container has nested types with ExtensionAttribute (C# 14 extension blocks)
+			var hasExtensionNestedTypes = type.GetTypeMembers().Any(nt =>
+				nt.GetAttributes().Any(a => a.AttributeClass?.ToFQDisplayString() == extensionAttributeName));
+
+			if (!hasExtensionNestedTypes)
+				continue;
+
+			// Look for get_PropertyName and set_PropertyName static methods
+			IMethodSymbol? getter = null;
+			IMethodSymbol? setter = null;
+
+			foreach (var method in type.GetMembers().OfType<IMethodSymbol>())
+			{
+				if (!method.IsStatic || method.DeclaredAccessibility != Accessibility.Public)
+					continue;
+
+				if (method.Name == getterName && method.Parameters.Length == 1)
+				{
+					var paramType = method.Parameters[0].Type;
+					if (IsAssignableFrom(paramType, targetType, context))
+					{
+						getter = method;
+					}
+				}
+				else if (method.Name == setterName && method.Parameters.Length == 2)
+				{
+					var paramType = method.Parameters[0].Type;
+					if (IsAssignableFrom(paramType, targetType, context))
+					{
+						setter = method;
+					}
+				}
+			}
+
+			if (getter != null || setter != null)
+			{
+				return (getter, setter);
+			}
+		}
+
+		return (null, null);
+	}
+
+	static IEnumerable<INamedTypeSymbol> GetAllTypesFromCompilation(Compilation compilation)
+	{
+		// Get types from all referenced assemblies
+		foreach (var reference in compilation.References)
+		{
+			if (compilation.GetAssemblyOrModuleSymbol(reference) is IAssemblySymbol assembly)
+			{
+				foreach (var type in GetAllTypesFromNamespace(assembly.GlobalNamespace))
+				{
+					yield return type;
+				}
+			}
+		}
+
+		// Get types from the current compilation
+		foreach (var type in GetAllTypesFromNamespace(compilation.GlobalNamespace))
+		{
+			yield return type;
+		}
+	}
+
+	static IEnumerable<INamedTypeSymbol> GetAllTypesFromNamespace(INamespaceSymbol namespaceSymbol)
+	{
+		foreach (var type in namespaceSymbol.GetTypeMembers())
+		{
+			yield return type;
+			foreach (var nested in GetNestedTypes(type))
+			{
+				yield return nested;
+			}
+		}
+
+		foreach (var nestedNs in namespaceSymbol.GetNamespaceMembers())
+		{
+			foreach (var type in GetAllTypesFromNamespace(nestedNs))
+			{
+				yield return type;
+			}
+		}
+	}
+
+	static IEnumerable<INamedTypeSymbol> GetNestedTypes(INamedTypeSymbol type)
+	{
+		foreach (var nested in type.GetTypeMembers())
+		{
+			yield return nested;
+			foreach (var deepNested in GetNestedTypes(nested))
+			{
+				yield return deepNested;
+			}
+		}
+	}
+
+	static bool IsAssignableFrom(ITypeSymbol baseType, ITypeSymbol derivedType, SourceGenContext context)
+	{
+		if (SymbolEqualityComparer.Default.Equals(baseType, derivedType))
+			return true;
+
+		return derivedType.InheritsFrom(baseType, context) || 
+		       (baseType.TypeKind == TypeKind.Interface && derivedType.AllInterfaces.Any(i => SymbolEqualityComparer.Default.Equals(i, baseType)));
+	}
+
+	static bool CanSetExtensionProperty(ILocalValue parentVar, string localName, INode node, SourceGenContext context)
+	{
+		var (getter, setter) = FindExtensionPropertyMethods(parentVar.Type, localName, context);
+		if (setter == null)
+			return false;
+
+		// Get the property type from the getter's return type or setter's second parameter
+		var propertyType = getter?.ReturnType ?? setter.Parameters[1].Type;
+
+		if (node is ValueNode vn && vn.CanConvertTo(propertyType, context))
+			return true;
+
+		if (node is not ElementNode elementNode)
+			return false;
+
+		if (!context.Variables.TryGetValue(elementNode, out var localVar))
+			return false;
+
+		if (localVar.Type.InheritsFrom(propertyType, context))
+			return true;
+
+		if (propertyType.TypeKind == TypeKind.Interface && localVar.Type.AllInterfaces.Any(i => SymbolEqualityComparer.Default.Equals(i, propertyType)))
+			return true;
+
+		if (propertyType.Equals(context.Compilation.ObjectType, SymbolEqualityComparer.Default))
+			return true;
+
+		if (context.Compilation.HasImplicitConversion(localVar.Type, propertyType))
+			return true;
+
+		return false;
+	}
+
+	static bool CanGetExtensionProperty(ILocalValue parentVar, string localName, SourceGenContext context, out ITypeSymbol? propertyType)
+	{
+		propertyType = null;
+		var (getter, _) = FindExtensionPropertyMethods(parentVar.Type, localName, context);
+		if (getter == null)
+			return false;
+
+		propertyType = getter.ReturnType;
+		return true;
+	}
+
+	static void SetExtensionProperty(IndentedTextWriter writer, ILocalValue parentVar, string localName, INode node, SourceGenContext context, NodeSGExtensions.GetNodeValueDelegate getNodeValue)
+	{
+		var (getter, setter) = FindExtensionPropertyMethods(parentVar.Type, localName, context);
+		
+		// Get the property type from the getter's return type or setter's second parameter
+		var propertyType = getter?.ReturnType ?? setter!.Parameters[1].Type;
+
+		// Generate: ExtensionClass.set_PropertyName(target, value)
+		var extensionClassName = setter!.ContainingType.ToFQDisplayString();
+		var setterName = setter.Name;
+
+		if (node is ValueNode valueNode)
+		{
+			using (context.ProjectItem.EnableLineInfo ? PrePost.NewLineInfo(writer, (IXmlLineInfo)node, context.ProjectItem) : PrePost.NoBlock())
+			{
+				var valueString = valueNode.ConvertTo(propertyType, writer, context, parentVar);
+				writer.WriteLine($"{extensionClassName}.{setterName}({parentVar.ValueAccessor}, {valueString});");
+			}
+		}
+		else if (node is ElementNode elementNode)
+		{
+			using (context.ProjectItem.EnableLineInfo ? PrePost.NewLineInfo(writer, (IXmlLineInfo)node, context.ProjectItem) : PrePost.NoBlock())
+			{
+				var localVar = getNodeValue(elementNode, context.Compilation.ObjectType);
+				string cast = string.Empty;
+				if (!context.Compilation.HasImplicitConversion(localVar.Type, propertyType))
+				{
+					cast = $"({propertyType.ToFQDisplayString()})";
+				}
+				writer.WriteLine($"{extensionClassName}.{setterName}({parentVar.ValueAccessor}, {cast}{localVar.ValueAccessor});");
+			}
+		}
+	}
+
+	static string GetExtensionProperty(ILocalValue parentVar, string localName, SourceGenContext context)
+	{
+		var (getter, _) = FindExtensionPropertyMethods(parentVar.Type, localName, context);
+		
+		// Generate: ExtensionClass.get_PropertyName(target)
+		var extensionClassName = getter!.ContainingType.ToFQDisplayString();
+		var getterName = getter.Name;
+
+		return $"{extensionClassName}.{getterName}({parentVar.ValueAccessor})";
+	}
 }
diff --git a/src/Controls/src/Xaml/ApplyPropertiesVisitor.cs b/src/Controls/src/Xaml/ApplyPropertiesVisitor.cs
index e513cb13e37c..58f36fc1c985 100644
--- a/src/Controls/src/Xaml/ApplyPropertiesVisitor.cs
+++ b/src/Controls/src/Xaml/ApplyPropertiesVisitor.cs
@@ -5,6 +5,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 using System.Xml;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Maui.Controls.Internals;
@@ -667,7 +668,10 @@ static bool TrySetProperty(object element, string localName, object value, IXmlL
 			var propertyInfo = elementType.GetRuntimeProperties().FirstOrDefault(p => p.Name == localName);
 			MethodInfo setter;
 			if (propertyInfo == null || !propertyInfo.CanWrite || (setter = propertyInfo.SetMethod) == null)
-				return false;
+			{
+				// Try to find a C# 14 extension property
+				return TrySetExtensionProperty(element, elementType, localName, value, lineInfo, serviceProvider, out exception);
+			}
 
 			if (!IsVisibleFrom(setter, rootElement))
 				return false;
@@ -691,6 +695,33 @@ static bool TrySetProperty(object element, string localName, object value, IXmlL
 			}
 		}
 
+		static bool TrySetExtensionProperty(object element, Type elementType, string propertyName, object value, IXmlLineInfo lineInfo, IServiceProvider serviceProvider, out Exception exception)
+		{
+			exception = null;
+
+			var (getter, setter) = FindExtensionPropertyMethods(elementType, propertyName);
+			if (setter == null)
+				return false;
+
+			// Get the property type from the getter's return type or setter's second parameter
+			Type propertyType = getter?.ReturnType ?? setter.GetParameters()[1].ParameterType;
+
+			object convertedValue = value.ConvertTo(propertyType, (Func<MemberInfo>)null, serviceProvider, out exception);
+			if (exception != null || (convertedValue != null && !propertyType.IsInstanceOfType(convertedValue)))
+				return false;
+
+			try
+			{
+				setter.Invoke(null, new object[] { element, convertedValue });
+				return true;
+			}
+			catch (Exception e)
+			{
+				exception = e;
+				return false;
+			}
+		}
+
 		static bool TryGetProperty(object element, string localName, out object value, IXmlLineInfo lineInfo, object rootElement, out Exception exception, out object targetProperty)
 		{
 			exception = null;
@@ -698,23 +729,27 @@ static bool TryGetProperty(object element, string localName, out object value, I
 			var elementType = element.GetType();
 			PropertyInfo propertyInfo = null;
 
-			while (elementType != null && propertyInfo == null)
+			var searchType = elementType;
+			while (searchType != null && propertyInfo == null)
 			{
 				try
 				{
-					propertyInfo = elementType.GetProperty(localName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly);
+					propertyInfo = searchType.GetProperty(localName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly);
 				}
 				catch (AmbiguousMatchException e)
 				{
-					throw new XamlParseException($"Multiple properties with name '{elementType}.{localName}' found.", lineInfo, innerException: e);
+					throw new XamlParseException($"Multiple properties with name '{searchType}.{localName}' found.", lineInfo, innerException: e);
 				}
-				elementType = elementType.BaseType;
+				searchType = searchType.BaseType;
 			}
 
 			MethodInfo getter;
 			targetProperty = propertyInfo;
 			if (propertyInfo == null || !propertyInfo.CanRead || (getter = propertyInfo.GetMethod) == null)
-				return false;
+			{
+				// Try to find a C# 14 extension property
+				return TryGetExtensionProperty(element, elementType, localName, out value, out exception, out targetProperty);
+			}
 
 			if (!IsVisibleFrom(getter, rootElement))
 				return false;
@@ -723,6 +758,30 @@ static bool TryGetProperty(object element, string localName, out object value, I
 			return true;
 		}
 
+		static bool TryGetExtensionProperty(object element, Type elementType, string propertyName, out object value, out Exception exception, out object targetProperty)
+		{
+			exception = null;
+			value = null;
+			targetProperty = null;
+
+			var (getter, _) = FindExtensionPropertyMethods(elementType, propertyName);
+			if (getter == null)
+				return false;
+
+			targetProperty = getter;
+
+			try
+			{
+				value = getter.Invoke(null, new object[] { element });
+				return true;
+			}
+			catch (Exception e)
+			{
+				exception = e;
+				return false;
+			}
+		}
+
 		static bool IsVisibleFrom(MethodInfo method, object rootElement)
 		{
 			if (method.IsPublic)
@@ -736,6 +795,109 @@ static bool IsVisibleFrom(MethodInfo method, object rootElement)
 			return false;
 		}
 
+		/// <summary>
+		/// Finds C# 14 extension property getter and setter methods for a given target type and property name.
+		/// Extension properties are compiled as static get_X/set_X methods in extension container types
+		/// that have nested types marked with ExtensionAttribute.
+		/// </summary>
+		static (MethodInfo Getter, MethodInfo Setter) FindExtensionPropertyMethods(Type targetType, string propertyName)
+		{
+			var getterName = $"get_{propertyName}";
+			var setterName = $"set_{propertyName}";
+
+			// Search all loaded assemblies for extension containers
+			foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+			{
+				// Skip dynamic and system assemblies for performance
+				if (assembly.IsDynamic)
+					continue;
+
+				Type[] types;
+				try
+				{
+					types = assembly.GetTypes();
+				}
+				catch (ReflectionTypeLoadException ex)
+				{
+					// Some types may fail to load, use the ones that succeeded
+					types = ex.Types.Where(t => t != null).ToArray();
+				}
+				catch
+				{
+					continue;
+				}
+
+				foreach (var type in types)
+				{
+					// Extension containers must be static classes with ExtensionAttribute
+					if (!type.IsAbstract || !type.IsSealed) // static classes are abstract and sealed
+						continue;
+
+					if (!type.IsDefined(typeof(ExtensionAttribute), false))
+						continue;
+
+					// Check if this container has nested types with ExtensionAttribute (C# 14 extension blocks)
+					var hasExtensionNestedTypes = false;
+					try
+					{
+						foreach (var nested in type.GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic))
+						{
+							if (nested.IsDefined(typeof(ExtensionAttribute), false))
+							{
+								hasExtensionNestedTypes = true;
+								break;
+							}
+						}
+					}
+					catch
+					{
+						continue;
+					}
+
+					if (!hasExtensionNestedTypes)
+						continue;
+
+					// Look for get_PropertyName and set_PropertyName static methods
+					MethodInfo getter = null;
+					MethodInfo setter = null;
+
+					try
+					{
+						foreach (var method in type.GetMethods(BindingFlags.Public | BindingFlags.Static))
+						{
+							if (method.Name == getterName)
+							{
+								var parameters = method.GetParameters();
+								if (parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(targetType))
+								{
+									getter = method;
+								}
+							}
+							else if (method.Name == setterName)
+							{
+								var parameters = method.GetParameters();
+								if (parameters.Length == 2 && parameters[0].ParameterType.IsAssignableFrom(targetType))
+								{
+									setter = method;
+								}
+							}
+						}
+					}
+					catch
+					{
+						continue;
+					}
+
+					if (getter != null || setter != null)
+					{
+						return (getter, setter);
+					}
+				}
+			}
+
+			return (null, null);
+		}
+
 		static bool TryAddToProperty(object element, XmlName propertyName, object value, string xKey, IXmlLineInfo lineInfo, IServiceProvider serviceProvider, object rootElement, out Exception exception)
 		{
 			exception = null;
diff --git a/src/Controls/tests/Xaml.UnitTests/ExtensionProperties.rtxc.xaml b/src/Controls/tests/Xaml.UnitTests/ExtensionProperties.rtxc.xaml
new file mode 100644
index 000000000000..fbcfb56fce05
--- /dev/null
+++ b/src/Controls/tests/Xaml.UnitTests/ExtensionProperties.rtxc.xaml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			xmlns:local="clr-namespace:Microsoft.Maui.Controls.Xaml.UnitTests"
+			x:Class="Microsoft.Maui.Controls.Xaml.UnitTests.ExtensionProperties"
+			x:DataType="local:ExtensionPropertiesViewModel">
+	<StackLayout>
+		<!-- Test 1: Setting a C# 14 extension property directly from XAML (like a regular property) -->
+		<Label x:Name="labelWithExtProp" MyTag="Hello from extension property" Text="Regular text" />
+		
+		<!-- Test 2: Setting multiple C# 14 extension properties from XAML -->
+		<Label x:Name="labelWithMultipleExtProps" MyTag="Tag value" MyPriority="42" Text="Another label" />
+		
+		<!-- Test 3: Binding to an extension property on the ViewModel (FullName uses C# 14 extension property) -->
+		<Label x:Name="labelWithBinding" Text="{Binding FullName}" />
+		
+		<!-- Test 4: Extension property with computed value (DisplayInfo uses C# 14 extension property) -->
+		<Label x:Name="labelWithComputedBinding" Text="{Binding DisplayInfo}" />
+		
+		<!-- Test 5: Extension property on collection used as binding source (IsEmpty uses C# 14 extension property) -->
+		<Label x:Name="labelWithIsEmptyBinding" Text="{Binding IsCollectionEmpty}" />
+	</StackLayout>
+</ContentPage>
diff --git a/src/Controls/tests/Xaml.UnitTests/ExtensionProperties.xaml.cs b/src/Controls/tests/Xaml.UnitTests/ExtensionProperties.xaml.cs
new file mode 100644
index 000000000000..6903db655e1e
--- /dev/null
+++ b/src/Controls/tests/Xaml.UnitTests/ExtensionProperties.xaml.cs
@@ -0,0 +1,235 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#nullable enable
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using Microsoft.Maui.Controls.Core.UnitTests;
+using Microsoft.Maui.Dispatching;
+using Microsoft.Maui.UnitTests;
+using NUnit.Framework;
+
+namespace Microsoft.Maui.Controls.Xaml.UnitTests;
+
+// C# 14 extension members for Label - adds properties directly to Label
+// These should be usable in XAML like regular properties: <Label MyTag="value" />
+public static class LabelExtensions
+{
+	private static readonly Dictionary<Label, string> _myTags = new();
+	private static readonly Dictionary<Label, int> _myPriorities = new();
+
+	// C# 14 extension properties - adds properties directly to Label type
+	extension(Label label)
+	{
+		public string MyTag
+		{
+			get => _myTags.TryGetValue(label, out var tag) ? tag : string.Empty;
+			set => _myTags[label] = value;
+		}
+
+		public int MyPriority
+		{
+			get => _myPriorities.TryGetValue(label, out var priority) ? priority : 0;
+			set => _myPriorities[label] = value;
+		}
+	}
+}
+
+// ViewModel with C# 14 extension properties
+public class PersonModel
+{
+	public string FirstName { get; set; } = string.Empty;
+	public string LastName { get; set; } = string.Empty;
+	public int Age { get; set; }
+}
+
+// C# 14 extension members that add computed properties to PersonModel
+public static class PersonModelExtensions
+{
+	extension(PersonModel person)
+	{
+		public string FullName => $"{person.FirstName} {person.LastName}";
+		public string DisplayInfo => $"{person.FirstName} {person.LastName} (Age: {person.Age})";
+	}
+}
+
+// C# 14 extension members that add properties to collections
+public static class CollectionExtensions
+{
+	extension<T>(ICollection<T> collection)
+	{
+		public bool IsEmpty => collection.Count == 0;
+	}
+}
+
+// ViewModel that exposes C# 14 extension properties through regular properties (for XAML binding)
+public class ExtensionPropertiesViewModel : INotifyPropertyChanged
+{
+	public event PropertyChangedEventHandler? PropertyChanged;
+
+	private PersonModel _person = new() { FirstName = "John", LastName = "Doe", Age = 30 };
+	public PersonModel Person
+	{
+		get => _person;
+		set
+		{
+			_person = value;
+			OnPropertyChanged();
+			OnPropertyChanged(nameof(FullName));
+			OnPropertyChanged(nameof(DisplayInfo));
+		}
+	}
+
+	// Expose C# 14 extension property through a regular property for XAML binding
+	public string FullName => _person.FullName;
+	public string DisplayInfo => _person.DisplayInfo;
+
+	private List<string> _items = new();
+	public List<string> Items
+	{
+		get => _items;
+		set
+		{
+			_items = value;
+			OnPropertyChanged();
+			OnPropertyChanged(nameof(IsCollectionEmpty));
+		}
+	}
+
+	// Expose C# 14 extension property on ICollection<T> through a regular property for XAML binding
+	public bool IsCollectionEmpty => _items.IsEmpty;
+
+	protected void OnPropertyChanged([CallerMemberName] string? propertyName = null)
+	{
+		PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+	}
+}
+
+// Runtime and XamlC now support C# 14 extension properties
+// SourceGen needs separate implementation (TBD: additional work needed)
+// Using .rtxc.xaml extension to restrict to Runtime and XamlC only
+public partial class ExtensionProperties : ContentPage
+{
+	public ExtensionProperties() => InitializeComponent();
+
+	[TestFixture]
+	class Tests
+	{
+		[SetUp]
+		public void Setup() => DispatcherProvider.SetCurrent(new DispatcherProviderStub());
+
+		[TearDown]
+		public void TearDown() => DispatcherProvider.SetCurrent(null);
+
+		[Test]
+		public void ExtensionPropertyCanBeSetFromXaml([Values(XamlInflator.Runtime, XamlInflator.XamlC)] XamlInflator inflator)
+		{
+			var page = new ExtensionProperties(inflator);
+
+			// Verify the C# 14 extension property was set from XAML (like a regular property)
+			Assert.That(page.labelWithExtProp.MyTag, Is.EqualTo("Hello from extension property"));
+			Assert.That(page.labelWithExtProp.Text, Is.EqualTo("Regular text"));
+		}
+
+		[Test]
+		public void MultipleExtensionPropertiesCanBeSetFromXaml([Values(XamlInflator.Runtime, XamlInflator.XamlC)] XamlInflator inflator)
+		{
+			var page = new ExtensionProperties(inflator);
+
+			// Verify multiple C# 14 extension properties were set from XAML
+			Assert.That(page.labelWithMultipleExtProps.MyTag, Is.EqualTo("Tag value"));
+			Assert.That(page.labelWithMultipleExtProps.MyPriority, Is.EqualTo(42));
+		}
+
+		[Test]
+		public void ExtensionPropertyCanBeSetAndReadInCode()
+		{
+			var label = new Label();
+
+			// Set via C# 14 extension property syntax
+			label.MyTag = "Test value";
+			label.MyPriority = 123;
+
+			// Read via C# 14 extension property syntax
+			Assert.That(label.MyTag, Is.EqualTo("Test value"));
+			Assert.That(label.MyPriority, Is.EqualTo(123));
+		}
+
+		[Test]
+		public void ExtensionPropertyOnViewModelCanBeBoundTo([Values(XamlInflator.Runtime, XamlInflator.XamlC)] XamlInflator inflator)
+		{
+			var vm = new ExtensionPropertiesViewModel
+			{
+				Person = new PersonModel { FirstName = "Jane", LastName = "Smith", Age = 25 }
+			};
+
+			var page = new ExtensionProperties(inflator)
+			{
+				BindingContext = vm
+			};
+
+			// Verify binding to FullName (which uses C# 14 extension property internally)
+			Assert.That(page.labelWithBinding.Text, Is.EqualTo("Jane Smith"));
+
+			// Verify binding to DisplayInfo (computed C# 14 extension property)
+			Assert.That(page.labelWithComputedBinding.Text, Is.EqualTo("Jane Smith (Age: 25)"));
+		}
+
+		[Test]
+		public void ExtensionPropertyOnCollectionWorks([Values(XamlInflator.Runtime, XamlInflator.XamlC)] XamlInflator inflator)
+		{
+			var vm = new ExtensionPropertiesViewModel
+			{
+				Items = new List<string>() // Empty list
+			};
+
+			var page = new ExtensionProperties(inflator)
+			{
+				BindingContext = vm
+			};
+
+			// Verify binding to IsCollectionEmpty (which uses C# 14 extension property on ICollection<T>)
+			Assert.That(page.labelWithIsEmptyBinding.Text, Is.EqualTo("True"));
+
+			// Update collection and verify change
+			vm.Items = new List<string> { "item1", "item2" };
+			Assert.That(page.labelWithIsEmptyBinding.Text, Is.EqualTo("False"));
+		}
+
+		[Test]
+		public void ExtensionPropertyUpdatesProperly([Values(XamlInflator.Runtime, XamlInflator.XamlC)] XamlInflator inflator)
+		{
+			var vm = new ExtensionPropertiesViewModel();
+			var page = new ExtensionProperties(inflator)
+			{
+				BindingContext = vm
+			};
+
+			// Initial value
+			Assert.That(page.labelWithBinding.Text, Is.EqualTo("John Doe"));
+
+			// Update the person and verify binding updates
+			vm.Person = new PersonModel { FirstName = "Alice", LastName = "Wonder", Age = 28 };
+			Assert.That(page.labelWithBinding.Text, Is.EqualTo("Alice Wonder"));
+			Assert.That(page.labelWithComputedBinding.Text, Is.EqualTo("Alice Wonder (Age: 28)"));
+		}
+
+		[Test]
+		public void ExtensionPropertyDirectUsageInCode()
+		{
+			// Test C# 14 extension properties can be used directly in C# code
+			var person = new PersonModel { FirstName = "Test", LastName = "User", Age = 42 };
+
+			// Using the C# 14 extension property syntax
+			Assert.That(person.FullName, Is.EqualTo("Test User"));
+			Assert.That(person.DisplayInfo, Is.EqualTo("Test User (Age: 42)"));
+
+			// Test C# 14 collection extension property
+			var emptyList = new List<int>();
+			var nonEmptyList = new List<int> { 1, 2, 3 };
+
+			Assert.That(emptyList.IsEmpty, Is.True);
+			Assert.That(nonEmptyList.IsEmpty, Is.False);
+		}
+	}
+}
diff --git a/src/Controls/tests/Xaml.UnitTests/ExtensionPropertiesBinding.xaml b/src/Controls/tests/Xaml.UnitTests/ExtensionPropertiesBinding.xaml
new file mode 100644
index 000000000000..64017d90a52f
--- /dev/null
+++ b/src/Controls/tests/Xaml.UnitTests/ExtensionPropertiesBinding.xaml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+			xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+			xmlns:local="clr-namespace:Microsoft.Maui.Controls.Xaml.UnitTests"
+			x:Class="Microsoft.Maui.Controls.Xaml.UnitTests.ExtensionPropertiesBinding"
+			x:DataType="local:OrderViewModel">
+	<StackLayout>
+		<!-- Binding to extension properties exposed through ViewModel -->
+		<Label x:Name="totalLabel" Text="{Binding FormattedTotal}" />
+		<Label x:Name="itemCountLabel" Text="{Binding ItemCountDisplay}" />
+		<Label x:Name="discountLabel" Text="{Binding DiscountedTotalDisplay}" />
+		
+		<!-- Binding to extension property used in a more complex scenario -->
+		<Label x:Name="summaryLabel" Text="{Binding OrderSummary}" />
+	</StackLayout>
+</ContentPage>
diff --git a/src/Controls/tests/Xaml.UnitTests/ExtensionPropertiesBinding.xaml.cs b/src/Controls/tests/Xaml.UnitTests/ExtensionPropertiesBinding.xaml.cs
new file mode 100644
index 000000000000..dac735642325
--- /dev/null
+++ b/src/Controls/tests/Xaml.UnitTests/ExtensionPropertiesBinding.xaml.cs
@@ -0,0 +1,288 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Globalization;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using Microsoft.Maui.Controls.Core.UnitTests;
+using Microsoft.Maui.Dispatching;
+using Microsoft.Maui.UnitTests;
+using NUnit.Framework;
+
+namespace Microsoft.Maui.Controls.Xaml.UnitTests;
+
+// Domain models
+public class OrderItem
+{
+	public string Name { get; set; } = string.Empty;
+	public decimal Price { get; set; }
+	public int Quantity { get; set; }
+}
+
+public class Order
+{
+	public List<OrderItem> Items { get; set; } = new();
+	public decimal DiscountPercent { get; set; }
+}
+
+// C# 14 extension members for OrderItem - adds computed properties
+public static class OrderItemExtensions
+{
+	extension(OrderItem item)
+	{
+		public decimal LineTotal => item.Price * item.Quantity;
+		public string FormattedLineTotal => item.LineTotal.ToString("F2", CultureInfo.InvariantCulture);
+	}
+}
+
+// C# 14 extension members for Order - adds computed properties that use other extension properties
+public static class OrderExtensions
+{
+	extension(Order order)
+	{
+		public decimal SubTotal => order.Items.Sum(i => i.LineTotal);
+		public decimal DiscountAmount => order.SubTotal * (order.DiscountPercent / 100m);
+		public decimal Total => order.SubTotal - order.DiscountAmount;
+		public int TotalItemCount => order.Items.Sum(i => i.Quantity);
+		
+		public string FormattedTotal => order.Total.ToString("F2", CultureInfo.InvariantCulture);
+		public string FormattedSubTotal => order.SubTotal.ToString("F2", CultureInfo.InvariantCulture);
+		public string FormattedDiscount => $"{order.DiscountAmount.ToString("F2", CultureInfo.InvariantCulture)} ({order.DiscountPercent}% off)";
+		
+		public string Summary => $"Order: {order.TotalItemCount} items, Total: {order.FormattedTotal}";
+	}
+}
+
+// C# 14 extension members for IEnumerable<OrderItem>
+public static class OrderItemCollectionExtensions
+{
+	extension(IEnumerable<OrderItem> items)
+	{
+		public decimal TotalValue => items.Sum(i => i.LineTotal);
+		public bool HasExpensiveItems => items.Any(i => i.Price > 100);
+	}
+}
+
+// ViewModel that exposes C# 14 extension properties through regular properties for XAML binding
+public class OrderViewModel : INotifyPropertyChanged
+{
+	public event PropertyChangedEventHandler? PropertyChanged;
+
+	private Order _order = new();
+	public Order Order
+	{
+		get => _order;
+		set
+		{
+			_order = value;
+			OnPropertyChanged();
+			NotifyOrderPropertiesChanged();
+		}
+	}
+
+	// Expose C# 14 extension properties through regular properties for XAML binding
+	public string FormattedTotal => _order.FormattedTotal;
+	public string ItemCountDisplay => $"{_order.TotalItemCount} items";
+	public string DiscountedTotalDisplay => _order.DiscountPercent > 0 
+		? $"{_order.FormattedSubTotal} → {_order.FormattedTotal} ({_order.FormattedDiscount})"
+		: _order.FormattedTotal;
+	public string OrderSummary => _order.Summary;
+
+	// Method to update items and notify property changes
+	public void AddItem(OrderItem item)
+	{
+		_order.Items.Add(item);
+		NotifyOrderPropertiesChanged();
+	}
+
+	public void SetDiscount(decimal percent)
+	{
+		_order.DiscountPercent = percent;
+		NotifyOrderPropertiesChanged();
+	}
+
+	private void NotifyOrderPropertiesChanged()
+	{
+		OnPropertyChanged(nameof(FormattedTotal));
+		OnPropertyChanged(nameof(ItemCountDisplay));
+		OnPropertyChanged(nameof(DiscountedTotalDisplay));
+		OnPropertyChanged(nameof(OrderSummary));
+	}
+
+	protected void OnPropertyChanged([CallerMemberName] string? propertyName = null)
+	{
+		PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+	}
+}
+
+public partial class ExtensionPropertiesBinding : ContentPage
+{
+	public ExtensionPropertiesBinding() => InitializeComponent();
+
+	[TestFixture]
+	class Tests
+	{
+		[SetUp]
+		public void Setup() => DispatcherProvider.SetCurrent(new DispatcherProviderStub());
+
+		[TearDown]
+		public void TearDown() => DispatcherProvider.SetCurrent(null);
+
+		[Test]
+		public void ExtensionPropertyBindingWithComputedValues([Values] XamlInflator inflator)
+		{
+			var vm = new OrderViewModel
+			{
+				Order = new Order
+				{
+					Items = new List<OrderItem>
+					{
+						new() { Name = "Widget", Price = 10.00m, Quantity = 2 },
+						new() { Name = "Gadget", Price = 25.00m, Quantity = 1 }
+					},
+					DiscountPercent = 0
+				}
+			};
+
+			var page = new ExtensionPropertiesBinding(inflator)
+			{
+				BindingContext = vm
+			};
+
+			// Total: (10 * 2) + (25 * 1) = 45.00
+			Assert.That(page.totalLabel.Text, Is.EqualTo("45.00"));
+			Assert.That(page.itemCountLabel.Text, Is.EqualTo("3 items"));
+		}
+
+		[Test]
+		public void ExtensionPropertyBindingWithDiscount([Values] XamlInflator inflator)
+		{
+			var vm = new OrderViewModel
+			{
+				Order = new Order
+				{
+					Items = new List<OrderItem>
+					{
+						new() { Name = "Product", Price = 100.00m, Quantity = 1 }
+					},
+					DiscountPercent = 10
+				}
+			};
+
+			var page = new ExtensionPropertiesBinding(inflator)
+			{
+				BindingContext = vm
+			};
+
+			// With 10% discount: $100 - $10 = $90
+			Assert.That(page.totalLabel.Text, Is.EqualTo("90.00"));
+			Assert.That(page.discountLabel.Text, Does.Contain("100.00"));
+			Assert.That(page.discountLabel.Text, Does.Contain("90.00"));
+			Assert.That(page.discountLabel.Text, Does.Contain("10%"));
+		}
+
+		[Test]
+		public void ExtensionPropertyBindingUpdatesOnChange([Values] XamlInflator inflator)
+		{
+			var vm = new OrderViewModel
+			{
+				Order = new Order
+				{
+					Items = new List<OrderItem>
+					{
+						new() { Name = "Item1", Price = 50.00m, Quantity = 1 }
+					}
+				}
+			};
+
+			var page = new ExtensionPropertiesBinding(inflator)
+			{
+				BindingContext = vm
+			};
+
+			Assert.That(page.totalLabel.Text, Is.EqualTo("50.00"));
+			Assert.That(page.itemCountLabel.Text, Is.EqualTo("1 items"));
+
+			// Add another item and verify binding updates
+			vm.AddItem(new OrderItem { Name = "Item2", Price = 30.00m, Quantity = 2 });
+
+			Assert.That(page.totalLabel.Text, Is.EqualTo("110.00"));
+			Assert.That(page.itemCountLabel.Text, Is.EqualTo("3 items"));
+		}
+
+		[Test]
+		public void ExtensionPropertyOnEnumerableWorks()
+		{
+			// Test C# 14 extension properties on IEnumerable<T>
+			var items = new List<OrderItem>
+			{
+				new() { Name = "Cheap", Price = 10.00m, Quantity = 5 },
+				new() { Name = "Expensive", Price = 150.00m, Quantity = 1 }
+			};
+
+			// Extension property: TotalValue
+			Assert.That(items.TotalValue, Is.EqualTo(200.00m)); // (10*5) + (150*1)
+
+			// Extension property: HasExpensiveItems
+			Assert.That(items.HasExpensiveItems, Is.True);
+
+			var cheapItems = new List<OrderItem>
+			{
+				new() { Name = "Budget1", Price = 5.00m, Quantity = 1 },
+				new() { Name = "Budget2", Price = 10.00m, Quantity = 1 }
+			};
+			Assert.That(cheapItems.HasExpensiveItems, Is.False);
+		}
+
+		[Test]
+		public void ExtensionPropertyChainedUsage()
+		{
+			// Test using extension properties that depend on other extension properties
+			var item = new OrderItem { Name = "Test", Price = 19.99m, Quantity = 3 };
+			
+			// LineTotal is an extension property
+			Assert.That(item.LineTotal, Is.EqualTo(59.97m));
+			Assert.That(item.FormattedLineTotal, Is.EqualTo("59.97"));
+
+			var order = new Order
+			{
+				Items = new List<OrderItem> { item },
+				DiscountPercent = 20
+			};
+
+			// These extension properties use other extension properties internally
+			Assert.That(order.SubTotal, Is.EqualTo(59.97m));
+			Assert.That(order.DiscountAmount, Is.EqualTo(11.994m));
+			Assert.That(order.Total, Is.EqualTo(47.976m));
+			Assert.That(order.Summary, Does.Contain("3 items"));
+		}
+
+		[Test]
+		public void ExtensionPropertySummaryBinding([Values] XamlInflator inflator)
+		{
+			var vm = new OrderViewModel
+			{
+				Order = new Order
+				{
+					Items = new List<OrderItem>
+					{
+						new() { Name = "A", Price = 10.00m, Quantity = 1 },
+						new() { Name = "B", Price = 20.00m, Quantity = 2 }
+					}
+				}
+			};
+
+			var page = new ExtensionPropertiesBinding(inflator)
+			{
+				BindingContext = vm
+			};
+
+			// Summary uses the extension property Order.Summary
+			Assert.That(page.summaryLabel.Text, Does.Contain("3 items"));
+			Assert.That(page.summaryLabel.Text, Does.Contain("50.00"));
+		}
+	}
+}

From 512e4b9fc2bb97ddbd148476f4592532d557214b Mon Sep 17 00:00:00 2001
From: Stephane Delcroix <stephane@delcroix.org>
Date: Fri, 28 Nov 2025 08:43:19 +0100
Subject: [PATCH 2/4] Simplify SourceGen extension property detection and
 update comments

- Remove nested type check from FindExtensionPropertyMethods (not needed)
- Update test comments to explain why SourceGen cannot yet support C# 14
  extension members (Roslyn needs to fully lower extension blocks before
  the semantic model exposes the generated accessor methods)
---
 src/Controls/src/SourceGen/SetPropertyHelpers.cs       | 10 +---------
 .../tests/Xaml.UnitTests/ExtensionProperties.xaml.cs   |  7 +++++--
 2 files changed, 6 insertions(+), 11 deletions(-)

diff --git a/src/Controls/src/SourceGen/SetPropertyHelpers.cs b/src/Controls/src/SourceGen/SetPropertyHelpers.cs
index d03cf7cd65af..7ccd925528e1 100644
--- a/src/Controls/src/SourceGen/SetPropertyHelpers.cs
+++ b/src/Controls/src/SourceGen/SetPropertyHelpers.cs
@@ -544,8 +544,7 @@ static void Add(IndentedTextWriter writer, ILocalValue parentVar, XmlName proper
 
 	/// <summary>
 	/// Finds C# 14 extension property getter and setter methods for a given target type and property name.
-	/// Extension properties are compiled as static get_X/set_X methods in extension container types
-	/// that have nested types marked with ExtensionAttribute.
+	/// Extension properties are compiled as static get_X/set_X methods in extension container types.
 	/// </summary>
 	static (IMethodSymbol? Getter, IMethodSymbol? Setter) FindExtensionPropertyMethods(
 		ITypeSymbol targetType, string propertyName, SourceGenContext context)
@@ -566,13 +565,6 @@ static void Add(IndentedTextWriter writer, ILocalValue parentVar, XmlName proper
 			if (!type.GetAttributes().Any(a => a.AttributeClass?.ToFQDisplayString() == extensionAttributeName))
 				continue;
 
-			// Check if this container has nested types with ExtensionAttribute (C# 14 extension blocks)
-			var hasExtensionNestedTypes = type.GetTypeMembers().Any(nt =>
-				nt.GetAttributes().Any(a => a.AttributeClass?.ToFQDisplayString() == extensionAttributeName));
-
-			if (!hasExtensionNestedTypes)
-				continue;
-
 			// Look for get_PropertyName and set_PropertyName static methods
 			IMethodSymbol? getter = null;
 			IMethodSymbol? setter = null;
diff --git a/src/Controls/tests/Xaml.UnitTests/ExtensionProperties.xaml.cs b/src/Controls/tests/Xaml.UnitTests/ExtensionProperties.xaml.cs
index 6903db655e1e..688157915e41 100644
--- a/src/Controls/tests/Xaml.UnitTests/ExtensionProperties.xaml.cs
+++ b/src/Controls/tests/Xaml.UnitTests/ExtensionProperties.xaml.cs
@@ -106,8 +106,11 @@ protected void OnPropertyChanged([CallerMemberName] string? propertyName = null)
 }
 
 // Runtime and XamlC now support C# 14 extension properties
-// SourceGen needs separate implementation (TBD: additional work needed)
-// Using .rtxc.xaml extension to restrict to Runtime and XamlC only
+// SourceGen: C# 14 extension members require Roslyn to fully lower the extension blocks
+// before the semantic model exposes get_/set_ accessor methods. Since SourceGen runs
+// during compilation (before full lowering), it cannot yet see the generated accessors.
+// This limitation may be resolved in future Roslyn versions with better C# 14 support.
+// Using .rtxc.xaml extension to restrict to Runtime and XamlC only for now.
 public partial class ExtensionProperties : ContentPage
 {
 	public ExtensionProperties() => InitializeComponent();

From eccafcfad82f9e8370f09b00d632fe6a41a61ad1 Mon Sep 17 00:00:00 2001
From: Stephane Delcroix <stephane@delcroix.org>
Date: Fri, 28 Nov 2025 08:55:03 +0100
Subject: [PATCH 3/4] Enable SourceGen support for C# 14 extension properties

- Updated FindExtensionProperty to find extension properties directly on
  static classes (Roslyn exposes them as IPropertySymbol with get_X/set_X
  accessor methods that take the target type as the first parameter)
- Removed ExtensionAttribute requirement since C# 14 extension blocks don't
  require it in the current Roslyn implementation
- Updated tests to use all three inflators ([Values] instead of explicit list)
- Renamed ExtensionProperties.rtxc.xaml to ExtensionProperties.xaml

All 1783 XAML unit tests pass
All 100 SourceGen unit tests pass
---
 .../src/SourceGen/SetPropertyHelpers.cs       | 139 +++++++++++++++---
 ...ies.rtxc.xaml => ExtensionProperties.xaml} |   0
 .../ExtensionProperties.xaml.cs               |  19 +--
 3 files changed, 129 insertions(+), 29 deletions(-)
 rename src/Controls/tests/Xaml.UnitTests/{ExtensionProperties.rtxc.xaml => ExtensionProperties.xaml} (100%)

diff --git a/src/Controls/src/SourceGen/SetPropertyHelpers.cs b/src/Controls/src/SourceGen/SetPropertyHelpers.cs
index 7ccd925528e1..69bf54554f5c 100644
--- a/src/Controls/src/SourceGen/SetPropertyHelpers.cs
+++ b/src/Controls/src/SourceGen/SetPropertyHelpers.cs
@@ -542,29 +542,69 @@ static void Add(IndentedTextWriter writer, ILocalValue parentVar, XmlName proper
 			writer.WriteLine($"{parentObj}.Add(({itemType.ToFQDisplayString()}){cast}{getNodeValue(valueNode, context.Compilation.ObjectType).ValueAccessor});");
 	}
 
+	/// <summary>
+	/// Finds C# 14 extension property for a given target type and property name.
+	/// In C# 14, extension properties appear directly on static classes with get_X/set_X accessor methods
+	/// that take the target type as the first parameter.
+	/// </summary>
+	static IPropertySymbol? FindExtensionProperty(
+		ITypeSymbol targetType, string propertyName, SourceGenContext context)
+	{
+		// Search all referenced assemblies and the current compilation
+		var allTypes = GetAllTypesFromCompilation(context.Compilation);
+
+		foreach (var type in allTypes)
+		{
+			// Extension containers must be static classes
+			if (!type.IsStatic)
+				continue;
+
+			// Look for the property directly on the static class
+			foreach (var prop in type.GetMembers().OfType<IPropertySymbol>())
+			{
+				if (prop.Name != propertyName)
+					continue;
+
+				// Check if this is an extension property by looking at the accessor parameters
+				var getter = prop.GetMethod;
+				var setter = prop.SetMethod;
+				
+				ITypeSymbol? extendedType = null;
+				if (getter != null && getter.Parameters.Length == 1)
+					extendedType = getter.Parameters[0].Type;
+				else if (setter != null && setter.Parameters.Length == 2)
+					extendedType = setter.Parameters[0].Type;
+
+				if (extendedType != null && IsAssignableFrom(extendedType, targetType, context))
+				{
+					return prop;
+				}
+			}
+		}
+
+		return null;
+	}
+
 	/// <summary>
 	/// Finds C# 14 extension property getter and setter methods for a given target type and property name.
-	/// Extension properties are compiled as static get_X/set_X methods in extension container types.
+	/// Extension properties are compiled as static get_X/set_X methods in static classes.
+	/// The getter has 1 parameter (the target) and the setter has 2 parameters (target, value).
 	/// </summary>
 	static (IMethodSymbol? Getter, IMethodSymbol? Setter) FindExtensionPropertyMethods(
 		ITypeSymbol targetType, string propertyName, SourceGenContext context)
 	{
 		var getterName = $"get_{propertyName}";
 		var setterName = $"set_{propertyName}";
-		var extensionAttributeName = "global::System.Runtime.CompilerServices.ExtensionAttribute";
 
 		// Search all referenced assemblies and the current compilation
 		var allTypes = GetAllTypesFromCompilation(context.Compilation);
 
 		foreach (var type in allTypes)
 		{
-			// Extension containers must be static classes (abstract and sealed) with ExtensionAttribute
+			// Extension containers must be static classes
 			if (!type.IsStatic)
 				continue;
 
-			if (!type.GetAttributes().Any(a => a.AttributeClass?.ToFQDisplayString() == extensionAttributeName))
-				continue;
-
 			// Look for get_PropertyName and set_PropertyName static methods
 			IMethodSymbol? getter = null;
 			IMethodSymbol? setter = null;
@@ -665,12 +705,24 @@ static bool IsAssignableFrom(ITypeSymbol baseType, ITypeSymbol derivedType, Sour
 
 	static bool CanSetExtensionProperty(ILocalValue parentVar, string localName, INode node, SourceGenContext context)
 	{
-		var (getter, setter) = FindExtensionPropertyMethods(parentVar.Type, localName, context);
-		if (setter == null)
-			return false;
+		ITypeSymbol? propertyType = null;
 
-		// Get the property type from the getter's return type or setter's second parameter
-		var propertyType = getter?.ReturnType ?? setter.Parameters[1].Type;
+		// First try to find extension property as IPropertySymbol (C# 14 semantic model)
+		var extProp = FindExtensionProperty(parentVar.Type, localName, context);
+		if (extProp != null && extProp.SetMethod != null)
+		{
+			propertyType = extProp.Type;
+		}
+		else
+		{
+			// Fall back to finding lowered accessor methods
+			var (getter, setter) = FindExtensionPropertyMethods(parentVar.Type, localName, context);
+			if (setter == null)
+				return false;
+
+			// Get the property type from the getter's return type or setter's second parameter
+			propertyType = getter?.ReturnType ?? setter.Parameters[1].Type;
+		}
 
 		if (node is ValueNode vn && vn.CanConvertTo(propertyType, context))
 			return true;
@@ -699,6 +751,16 @@ static bool CanSetExtensionProperty(ILocalValue parentVar, string localName, INo
 	static bool CanGetExtensionProperty(ILocalValue parentVar, string localName, SourceGenContext context, out ITypeSymbol? propertyType)
 	{
 		propertyType = null;
+		
+		// First try to find extension property as IPropertySymbol (C# 14 semantic model)
+		var extProp = FindExtensionProperty(parentVar.Type, localName, context);
+		if (extProp != null && extProp.GetMethod != null)
+		{
+			propertyType = extProp.Type;
+			return true;
+		}
+
+		// Fall back to finding lowered accessor methods
 		var (getter, _) = FindExtensionPropertyMethods(parentVar.Type, localName, context);
 		if (getter == null)
 			return false;
@@ -709,32 +771,64 @@ static bool CanGetExtensionProperty(ILocalValue parentVar, string localName, Sou
 
 	static void SetExtensionProperty(IndentedTextWriter writer, ILocalValue parentVar, string localName, INode node, SourceGenContext context, NodeSGExtensions.GetNodeValueDelegate getNodeValue)
 	{
+		// First try to find extension property as IPropertySymbol (C# 14 semantic model)
+		var extProp = FindExtensionProperty(parentVar.Type, localName, context);
+		if (extProp != null)
+		{
+			// Generate code using property access syntax - the compiler will handle it
+			var propertyType = extProp.Type;
+
+			if (node is ValueNode valueNode)
+			{
+				using (context.ProjectItem.EnableLineInfo ? PrePost.NewLineInfo(writer, (IXmlLineInfo)node, context.ProjectItem) : PrePost.NoBlock())
+				{
+					var valueString = valueNode.ConvertTo(propertyType, writer, context, parentVar);
+					writer.WriteLine($"{parentVar.ValueAccessor}.{localName} = {valueString};");
+				}
+			}
+			else if (node is ElementNode elementNode)
+			{
+				using (context.ProjectItem.EnableLineInfo ? PrePost.NewLineInfo(writer, (IXmlLineInfo)node, context.ProjectItem) : PrePost.NoBlock())
+				{
+					var localVar = getNodeValue(elementNode, context.Compilation.ObjectType);
+					string cast = string.Empty;
+					if (!context.Compilation.HasImplicitConversion(localVar.Type, propertyType))
+					{
+						cast = $"({propertyType.ToFQDisplayString()})";
+					}
+					writer.WriteLine($"{parentVar.ValueAccessor}.{localName} = {cast}{localVar.ValueAccessor};");
+				}
+			}
+			return;
+		}
+
+		// Fall back to lowered accessor methods
 		var (getter, setter) = FindExtensionPropertyMethods(parentVar.Type, localName, context);
 		
 		// Get the property type from the getter's return type or setter's second parameter
-		var propertyType = getter?.ReturnType ?? setter!.Parameters[1].Type;
+		var propType = getter?.ReturnType ?? setter!.Parameters[1].Type;
 
 		// Generate: ExtensionClass.set_PropertyName(target, value)
 		var extensionClassName = setter!.ContainingType.ToFQDisplayString();
 		var setterName = setter.Name;
 
-		if (node is ValueNode valueNode)
+		if (node is ValueNode vn)
 		{
 			using (context.ProjectItem.EnableLineInfo ? PrePost.NewLineInfo(writer, (IXmlLineInfo)node, context.ProjectItem) : PrePost.NoBlock())
 			{
-				var valueString = valueNode.ConvertTo(propertyType, writer, context, parentVar);
+				var valueString = vn.ConvertTo(propType, writer, context, parentVar);
 				writer.WriteLine($"{extensionClassName}.{setterName}({parentVar.ValueAccessor}, {valueString});");
 			}
 		}
-		else if (node is ElementNode elementNode)
+		else if (node is ElementNode en)
 		{
 			using (context.ProjectItem.EnableLineInfo ? PrePost.NewLineInfo(writer, (IXmlLineInfo)node, context.ProjectItem) : PrePost.NoBlock())
 			{
-				var localVar = getNodeValue(elementNode, context.Compilation.ObjectType);
+				var localVar = getNodeValue(en, context.Compilation.ObjectType);
 				string cast = string.Empty;
-				if (!context.Compilation.HasImplicitConversion(localVar.Type, propertyType))
+				if (!context.Compilation.HasImplicitConversion(localVar.Type, propType))
 				{
-					cast = $"({propertyType.ToFQDisplayString()})";
+					cast = $"({propType.ToFQDisplayString()})";
 				}
 				writer.WriteLine($"{extensionClassName}.{setterName}({parentVar.ValueAccessor}, {cast}{localVar.ValueAccessor});");
 			}
@@ -743,6 +837,15 @@ static void SetExtensionProperty(IndentedTextWriter writer, ILocalValue parentVa
 
 	static string GetExtensionProperty(ILocalValue parentVar, string localName, SourceGenContext context)
 	{
+		// First try to find extension property as IPropertySymbol (C# 14 semantic model)
+		var extProp = FindExtensionProperty(parentVar.Type, localName, context);
+		if (extProp != null)
+		{
+			// Generate code using property access syntax - the compiler will handle it
+			return $"{parentVar.ValueAccessor}.{localName}";
+		}
+
+		// Fall back to lowered accessor methods
 		var (getter, _) = FindExtensionPropertyMethods(parentVar.Type, localName, context);
 		
 		// Generate: ExtensionClass.get_PropertyName(target)
diff --git a/src/Controls/tests/Xaml.UnitTests/ExtensionProperties.rtxc.xaml b/src/Controls/tests/Xaml.UnitTests/ExtensionProperties.xaml
similarity index 100%
rename from src/Controls/tests/Xaml.UnitTests/ExtensionProperties.rtxc.xaml
rename to src/Controls/tests/Xaml.UnitTests/ExtensionProperties.xaml
diff --git a/src/Controls/tests/Xaml.UnitTests/ExtensionProperties.xaml.cs b/src/Controls/tests/Xaml.UnitTests/ExtensionProperties.xaml.cs
index 688157915e41..93f9c0286080 100644
--- a/src/Controls/tests/Xaml.UnitTests/ExtensionProperties.xaml.cs
+++ b/src/Controls/tests/Xaml.UnitTests/ExtensionProperties.xaml.cs
@@ -105,12 +105,9 @@ protected void OnPropertyChanged([CallerMemberName] string? propertyName = null)
 	}
 }
 
-// Runtime and XamlC now support C# 14 extension properties
-// SourceGen: C# 14 extension members require Roslyn to fully lower the extension blocks
-// before the semantic model exposes get_/set_ accessor methods. Since SourceGen runs
-// during compilation (before full lowering), it cannot yet see the generated accessors.
-// This limitation may be resolved in future Roslyn versions with better C# 14 support.
-// Using .rtxc.xaml extension to restrict to Runtime and XamlC only for now.
+// All XAML inflators (Runtime, XamlC, SourceGen) now support C# 14 extension properties.
+// Extension properties appear as IPropertySymbol on static classes with get_X/set_X accessors
+// that take the target type as the first parameter.
 public partial class ExtensionProperties : ContentPage
 {
 	public ExtensionProperties() => InitializeComponent();
@@ -125,7 +122,7 @@ class Tests
 		public void TearDown() => DispatcherProvider.SetCurrent(null);
 
 		[Test]
-		public void ExtensionPropertyCanBeSetFromXaml([Values(XamlInflator.Runtime, XamlInflator.XamlC)] XamlInflator inflator)
+		public void ExtensionPropertyCanBeSetFromXaml([Values] XamlInflator inflator)
 		{
 			var page = new ExtensionProperties(inflator);
 
@@ -135,7 +132,7 @@ public void ExtensionPropertyCanBeSetFromXaml([Values(XamlInflator.Runtime, Xaml
 		}
 
 		[Test]
-		public void MultipleExtensionPropertiesCanBeSetFromXaml([Values(XamlInflator.Runtime, XamlInflator.XamlC)] XamlInflator inflator)
+		public void MultipleExtensionPropertiesCanBeSetFromXaml([Values] XamlInflator inflator)
 		{
 			var page = new ExtensionProperties(inflator);
 
@@ -159,7 +156,7 @@ public void ExtensionPropertyCanBeSetAndReadInCode()
 		}
 
 		[Test]
-		public void ExtensionPropertyOnViewModelCanBeBoundTo([Values(XamlInflator.Runtime, XamlInflator.XamlC)] XamlInflator inflator)
+		public void ExtensionPropertyOnViewModelCanBeBoundTo([Values] XamlInflator inflator)
 		{
 			var vm = new ExtensionPropertiesViewModel
 			{
@@ -179,7 +176,7 @@ public void ExtensionPropertyOnViewModelCanBeBoundTo([Values(XamlInflator.Runtim
 		}
 
 		[Test]
-		public void ExtensionPropertyOnCollectionWorks([Values(XamlInflator.Runtime, XamlInflator.XamlC)] XamlInflator inflator)
+		public void ExtensionPropertyOnCollectionWorks([Values] XamlInflator inflator)
 		{
 			var vm = new ExtensionPropertiesViewModel
 			{
@@ -200,7 +197,7 @@ public void ExtensionPropertyOnCollectionWorks([Values(XamlInflator.Runtime, Xam
 		}
 
 		[Test]
-		public void ExtensionPropertyUpdatesProperly([Values(XamlInflator.Runtime, XamlInflator.XamlC)] XamlInflator inflator)
+		public void ExtensionPropertyUpdatesProperly([Values] XamlInflator inflator)
 		{
 			var vm = new ExtensionPropertiesViewModel();
 			var page = new ExtensionProperties(inflator)

From 77b97ce9ad805cafd2558c51cf5b8926c40f865a Mon Sep 17 00:00:00 2001
From: Stephane Delcroix <stephane@delcroix.org>
Date: Fri, 28 Nov 2025 09:45:58 +0100
Subject: [PATCH 4/4] Add caching for extension property lookups to improve
 SourceGen performance

- Cache list of all static types per context (expensive enumeration once)
- Cache individual extension property lookups by (targetType, propertyName)
- Cache extension property method lookups by (targetType, propertyName)
- Use SymbolEqualityComparer for cache key comparison

Performance results (Controls.Xaml.UnitTests build):
- Before: 27.81s (baseline without extension property feature)
- After:  16.78s (~40% faster than baseline)

The caching makes the extension property feature actually improve build times
because the static type enumeration is now shared across all lookups.
---
 .../src/SourceGen/SetPropertyHelpers.cs       | 76 +++++++++++++++----
 .../src/SourceGen/SourceGenContext.cs         |  5 ++
 2 files changed, 66 insertions(+), 15 deletions(-)

diff --git a/src/Controls/src/SourceGen/SetPropertyHelpers.cs b/src/Controls/src/SourceGen/SetPropertyHelpers.cs
index 69bf54554f5c..94faca89d944 100644
--- a/src/Controls/src/SourceGen/SetPropertyHelpers.cs
+++ b/src/Controls/src/SourceGen/SetPropertyHelpers.cs
@@ -546,19 +546,24 @@ static void Add(IndentedTextWriter writer, ILocalValue parentVar, XmlName proper
 	/// Finds C# 14 extension property for a given target type and property name.
 	/// In C# 14, extension properties appear directly on static classes with get_X/set_X accessor methods
 	/// that take the target type as the first parameter.
+	/// Results are cached per context to avoid repeated searches.
 	/// </summary>
 	static IPropertySymbol? FindExtensionProperty(
 		ITypeSymbol targetType, string propertyName, SourceGenContext context)
 	{
-		// Search all referenced assemblies and the current compilation
-		var allTypes = GetAllTypesFromCompilation(context.Compilation);
+		// Use cache if available
+		context.extensionPropertyCache ??= new Dictionary<(ITypeSymbol, string), IPropertySymbol?>(
+			new ExtensionPropertyKeyComparer());
+		
+		var key = (targetType, propertyName);
+		if (context.extensionPropertyCache.TryGetValue(key, out var cachedResult))
+			return cachedResult;
 
-		foreach (var type in allTypes)
+		// Search through all static types
+		var allStaticTypes = GetAllStaticTypes(context);
+		
+		foreach (var type in allStaticTypes)
 		{
-			// Extension containers must be static classes
-			if (!type.IsStatic)
-				continue;
-
 			// Look for the property directly on the static class
 			foreach (var prop in type.GetMembers().OfType<IPropertySymbol>())
 			{
@@ -577,11 +582,13 @@ static void Add(IndentedTextWriter writer, ILocalValue parentVar, XmlName proper
 
 				if (extendedType != null && IsAssignableFrom(extendedType, targetType, context))
 				{
+					context.extensionPropertyCache[key] = prop;
 					return prop;
 				}
 			}
 		}
 
+		context.extensionPropertyCache[key] = null;
 		return null;
 	}
 
@@ -589,22 +596,27 @@ static void Add(IndentedTextWriter writer, ILocalValue parentVar, XmlName proper
 	/// Finds C# 14 extension property getter and setter methods for a given target type and property name.
 	/// Extension properties are compiled as static get_X/set_X methods in static classes.
 	/// The getter has 1 parameter (the target) and the setter has 2 parameters (target, value).
+	/// Results are cached per context to avoid repeated searches.
 	/// </summary>
 	static (IMethodSymbol? Getter, IMethodSymbol? Setter) FindExtensionPropertyMethods(
 		ITypeSymbol targetType, string propertyName, SourceGenContext context)
 	{
+		// Use cache if available
+		context.extensionPropertyMethodsCache ??= new Dictionary<(ITypeSymbol, string), (IMethodSymbol?, IMethodSymbol?)>(
+			new ExtensionPropertyKeyComparer());
+		
+		var key = (targetType, propertyName);
+		if (context.extensionPropertyMethodsCache.TryGetValue(key, out var cachedResult))
+			return cachedResult;
+
 		var getterName = $"get_{propertyName}";
 		var setterName = $"set_{propertyName}";
 
-		// Search all referenced assemblies and the current compilation
-		var allTypes = GetAllTypesFromCompilation(context.Compilation);
+		// Search through all static types
+		var allStaticTypes = GetAllStaticTypes(context);
 
-		foreach (var type in allTypes)
+		foreach (var type in allStaticTypes)
 		{
-			// Extension containers must be static classes
-			if (!type.IsStatic)
-				continue;
-
 			// Look for get_PropertyName and set_PropertyName static methods
 			IMethodSymbol? getter = null;
 			IMethodSymbol? setter = null;
@@ -634,13 +646,47 @@ static void Add(IndentedTextWriter writer, ILocalValue parentVar, XmlName proper
 
 			if (getter != null || setter != null)
 			{
-				return (getter, setter);
+				var result = (getter, setter);
+				context.extensionPropertyMethodsCache[key] = result;
+				return result;
 			}
 		}
 
+		context.extensionPropertyMethodsCache[key] = (null, null);
 		return (null, null);
 	}
 
+	/// <summary>
+	/// Comparer for extension property cache keys that uses symbol equality.
+	/// </summary>
+	sealed class ExtensionPropertyKeyComparer : IEqualityComparer<(ITypeSymbol, string)>
+	{
+		public bool Equals((ITypeSymbol, string) x, (ITypeSymbol, string) y)
+			=> SymbolEqualityComparer.Default.Equals(x.Item1, y.Item1) && x.Item2 == y.Item2;
+
+		public int GetHashCode((ITypeSymbol, string) obj)
+			=> SymbolEqualityComparer.Default.GetHashCode(obj.Item1) ^ obj.Item2.GetHashCode();
+	}
+
+	/// <summary>
+	/// Gets all static types from the compilation, with caching to avoid repeated enumeration.
+	/// </summary>
+	static INamedTypeSymbol[] GetAllStaticTypes(SourceGenContext context)
+	{
+		if (context.allStaticTypesCache != null)
+			return context.allStaticTypesCache;
+
+		var staticTypes = new List<INamedTypeSymbol>();
+		foreach (var type in GetAllTypesFromCompilation(context.Compilation))
+		{
+			if (type.IsStatic)
+				staticTypes.Add(type);
+		}
+		
+		context.allStaticTypesCache = staticTypes.ToArray();
+		return context.allStaticTypesCache;
+	}
+
 	static IEnumerable<INamedTypeSymbol> GetAllTypesFromCompilation(Compilation compilation)
 	{
 		// Get types from all referenced assemblies
diff --git a/src/Controls/src/SourceGen/SourceGenContext.cs b/src/Controls/src/SourceGen/SourceGenContext.cs
index 89c679f5d10c..33f90b0ee8a8 100644
--- a/src/Controls/src/SourceGen/SourceGenContext.cs
+++ b/src/Controls/src/SourceGen/SourceGenContext.cs
@@ -45,6 +45,11 @@ class SourceGenContext(IndentedTextWriter writer, Compilation compilation, Sourc
 
 	public Dictionary<string, int> lastIdForName = [];
 
+	// Cache for C# 14 extension property lookups to avoid repeated searches through all types
+	internal Dictionary<(ITypeSymbol, string), IPropertySymbol?>? extensionPropertyCache;
+	internal Dictionary<(ITypeSymbol, string), (IMethodSymbol?, IMethodSymbol?)>? extensionPropertyMethodsCache;
+	internal INamedTypeSymbol[]? allStaticTypesCache;
+
 	public void AddLocalMethod(string code)
 	{
 		if (ParentContext != null)