Update IComponentPropertyActivator section

Author: danroth27

release-notes/11.0/preview/preview1/aspnetcore.md

@@ -286,36 +286,68 @@ The analyzer helps catch performance issues where `InvokeAsync` is unnecessarily
 
 ## `IComponentPropertyActivator` for custom property injection
 
-Blazor now provides a new `IComponentPropertyActivator` interface for customizing property injection in components. This public abstraction enables advanced scenarios like custom DI containers, Blazor Hybrid scenarios, or specialized property resolution logic.
+Blazor now provides `IComponentPropertyActivator` for customizing how `[Inject]` properties are populated on components. This enables advanced scenarios like:
+
+- Providing additional context for property resolution
+- Support for custom DI containers that need to intercept property injection
+- Advanced scenarios requiring property injection customization
 
 ```csharp
 public interface IComponentPropertyActivator
 {
-    Action<IServiceProvider, object> GetActivator(
+    Action<IServiceProvider, IComponent> GetActivator(
         [DynamicallyAccessedMembers(Component)] Type componentType);
 }
 ```
 
-**Usage:**
+**Example: Logging property activator**
 
 ```csharp
-public class CustomPropertyActivator : IComponentPropertyActivator
+public class LoggingPropertyActivator : IComponentPropertyActivator
 {
-    public Action<IServiceProvider, object> GetActivator(Type componentType)
+    private readonly ILogger<LoggingPropertyActivator> _logger;
+    private readonly ConcurrentDictionary<Type, Action<IServiceProvider, IComponent>> _cache = new();
+
+    public LoggingPropertyActivator(ILogger<LoggingPropertyActivator> logger)
+    {
+        _logger = logger;
+    }
+
+    public Action<IServiceProvider, IComponent> GetActivator(Type componentType)
     {
-        return (serviceProvider, component) =>
+        return _cache.GetOrAdd(componentType, type =>
         {
-            // Custom property injection logic
-            // Access component properties and inject dependencies
-        };
+            var injectProperties = type
+                .GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
+                .Where(p => p.GetCustomAttribute<InjectAttribute>() != null)
+                .ToList();
+
+            return (serviceProvider, component) =>
+            {
+                foreach (var property in injectProperties)
+                {
+                    var injectAttr = property.GetCustomAttribute<InjectAttribute>();
+                    object? service = injectAttr?.Key != null
+                        ? serviceProvider.GetKeyedService(property.PropertyType, injectAttr.Key)
+                        : serviceProvider.GetService(property.PropertyType);
+
+                    if (service != null)
+                    {
+                        _logger.LogDebug("Injecting {Service} into {Component}.{Property}",
+                            property.PropertyType.Name, type.Name, property.Name);
+                        property.SetValue(component, service);
+                    }
+                }
+            };
+        });
     }
 }
 
-// Registration
-services.AddSingleton<IComponentPropertyActivator, CustomPropertyActivator>();
+// Registration - replaces default property injection
+builder.Services.AddSingleton<IComponentPropertyActivator, LoggingPropertyActivator>();
 ```
 
-The interface follows the same pattern as MVC's property activators and integrates with Hot Reload for cache invalidation. The default implementation supports keyed services via `[Inject(Key = "...")]` and includes proper trimming annotations for AOT compatibility.
+The default implementation caches activators per component type, supports keyed services via `[Inject(Key = "...")]`, integrates with Hot Reload for cache invalidation, and includes proper trimming annotations for AOT compatibility.
 
 ## SignalR `ConfigureConnection` for Interactive Server components