Merging main into darc-main-6a500fc6-cc1d-4c69-9b8a-a7d84549614e

Author: dotnet-maestro[bot]

src/Components/Components/src/PublicAPI.Unshipped.txt

@@ -18,3 +18,4 @@ static Microsoft.AspNetCore.Components.Infrastructure.RegisterPersistentComponen
 static Microsoft.AspNetCore.Components.Infrastructure.ComponentsMetricsServiceCollectionExtensions.AddComponentsMetrics(Microsoft.Extensions.DependencyInjection.IServiceCollection! services) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!
 static Microsoft.AspNetCore.Components.Infrastructure.ComponentsMetricsServiceCollectionExtensions.AddComponentsTracing(Microsoft.Extensions.DependencyInjection.IServiceCollection! services) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!
 static Microsoft.Extensions.DependencyInjection.SupplyParameterFromPersistentComponentStateProviderServiceCollectionExtensions.AddSupplyValueFromPersistentComponentStateProvider(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!
+virtual Microsoft.AspNetCore.Components.Rendering.ComponentState.GetComponentKey() -> object?

src/Components/Components/src/Reflection/PropertyGetter.cs

@@ -33,8 +33,10 @@ public PropertyGetter(Type targetType, PropertyInfo property)
 
             var propertyGetterAsFunc =
                 getMethod.CreateDelegate(typeof(Func<,>).MakeGenericType(targetType, property.PropertyType));
+
             var callPropertyGetterClosedGenericMethod =
                 CallPropertyGetterOpenGenericMethod.MakeGenericMethod(targetType, property.PropertyType);
+
             _GetterDelegate = (Func<object, object>)
                 callPropertyGetterClosedGenericMethod.CreateDelegate(typeof(Func<object, object>), propertyGetterAsFunc);
         }
@@ -46,11 +48,11 @@ public PropertyGetter(Type targetType, PropertyInfo property)
 
     public object? GetValue(object target) => _GetterDelegate(target);
 
-    private static TValue CallPropertyGetter<TTarget, TValue>(
+    private static object? CallPropertyGetter<TTarget, TValue>(
         Func<TTarget, TValue> Getter,
         object target)
         where TTarget : notnull
     {
-        return Getter((TTarget)target);
+        return (object?)Getter((TTarget)target);
     }
 }

src/Components/Components/src/Rendering/ComponentState.cs

@@ -339,6 +339,36 @@ internal ValueTask DisposeInBatchAsync(RenderBatchBuilder batchBuilder)
         return DisposeAsync();
     }
 
+    /// <summary>
+    /// Gets the component key for this component instance.
+    /// This is used for state persistence and component identification across render modes.
+    /// </summary>
+    /// <returns>The component key, or null if no key is available.</returns>
+    protected internal virtual object? GetComponentKey()
+    {
+        if (ParentComponentState is not { } parentComponentState)
+        {
+            return null;
+        }
+
+        // Check if the parentComponentState has a `@key` directive applied to the current component.
+        var frames = parentComponentState.CurrentRenderTree.GetFrames();
+        for (var i = 0; i < frames.Count; i++)
+        {
+            ref var currentFrame = ref frames.Array[i];
+            if (currentFrame.FrameType != RenderTreeFrameType.Component ||
+                !ReferenceEquals(Component, currentFrame.Component))
+            {
+                // Skip any frame that is not the current component.
+                continue;
+            }
+
+            return currentFrame.ComponentKey;
+        }
+
+        return null;
+    }
+
     private string GetDebuggerDisplay()
     {
         return $"ComponentId = {ComponentId}, Type = {Component.GetType().Name}, Disposed = {_componentWasDisposed}";

src/Components/Components/src/SupplyParameterFromPersistentComponentStateValueProvider.cs

@@ -45,7 +45,9 @@ public bool CanSupplyValue(in CascadingParameterInfo parameterInfo)
         return state.TryTakeFromJson(storageKey, parameterInfo.PropertyType, out var value) ? value : null;
     }
 
-    [UnconditionalSuppressMessage("Trimming", "IL2075:'this' argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The return value of the source method does not have matching annotations.", Justification = "OpenComponent already has the right set of attributes")] [UnconditionalSuppressMessage("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", Justification = "OpenComponent already has the right set of attributes")] [UnconditionalSuppressMessage("Trimming", "IL2072:Target parameter argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The return value of the source method does not have matching annotations.", Justification = "OpenComponent already has the right set of attributes")]
+    [UnconditionalSuppressMessage("Trimming", "IL2075:'this' argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The return value of the source method does not have matching annotations.", Justification = "OpenComponent already has the right set of attributes")]
+    [UnconditionalSuppressMessage("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", Justification = "OpenComponent already has the right set of attributes")]
+    [UnconditionalSuppressMessage("Trimming", "IL2072:Target parameter argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The return value of the source method does not have matching annotations.", Justification = "OpenComponent already has the right set of attributes")]
     public void Subscribe(ComponentState subscriber, in CascadingParameterInfo parameterInfo)
     {
         var propertyName = parameterInfo.PropertyName;
@@ -221,35 +223,46 @@ private static void GrowBuffer(ref byte[]? pool, ref Span<byte> keyBuffer, int?
 
     private static object? GetSerializableKey(ComponentState componentState)
     {
-        if (componentState.ParentComponentState is not { } parentComponentState)
+        var componentKey = componentState.GetComponentKey();
+        if (componentKey != null && IsSerializableKey(componentKey))
         {
-            return null;
+            return componentKey;
         }
 
-        // Check if the parentComponentState has a `@key` directive applied to the current component.
-        var frames = parentComponentState.CurrentRenderTree.GetFrames();
-        for (var i = 0; i < frames.Count; i++)
+        return null;
+    }
+
+    private static string GetComponentType(ComponentState componentState) => componentState.Component.GetType().FullName!;
+
+    private static string GetParentComponentType(ComponentState componentState)
+    {
+        if (componentState.ParentComponentState == null)
+        {
+            return "";
+        }
+        if (componentState.ParentComponentState.Component == null)
         {
-            ref var currentFrame = ref frames.Array[i];
-            if (currentFrame.FrameType != RenderTree.RenderTreeFrameType.Component ||
-                !ReferenceEquals(componentState.Component, currentFrame.Component))
+            return "";
+        }
+
+        if (componentState.ParentComponentState.ParentComponentState != null)
+        {
+            var renderer = componentState.Renderer;
+            var parentRenderMode = renderer.GetComponentRenderMode(componentState.ParentComponentState.Component);
+            var grandParentRenderMode = renderer.GetComponentRenderMode(componentState.ParentComponentState.ParentComponentState.Component);
+            if (parentRenderMode != grandParentRenderMode)
             {
-                // Skip any frame that is not the current component.
-                continue;
+                // This is the case when EndpointHtmlRenderer introduces an SSRRenderBoundary component.
+                // We want to return "" because the SSRRenderBoundary component is not a real component
+                // and won't appear on the component tree in the WebAssemblyRenderer and RemoteRenderer
+                // interactive scenarios.
+                return "";
             }
-
-            var componentKey = currentFrame.ComponentKey;
-            return !IsSerializableKey(componentKey) ? null : componentKey;
         }
 
-        return null;
+        return GetComponentType(componentState.ParentComponentState);
     }
 
-    private static string GetComponentType(ComponentState componentState) => componentState.Component.GetType().FullName!;
-
-    private static string GetParentComponentType(ComponentState componentState) =>
-        componentState.ParentComponentState == null ? "" : GetComponentType(componentState.ParentComponentState);
-
     private static byte[] KeyFactory((string parentComponentType, string componentType, string propertyName) parts) =>
         SHA256.HashData(Encoding.UTF8.GetBytes(string.Join(".", parts.parentComponentType, parts.componentType, parts.propertyName)));
 

src/Components/Components/test/SupplyParameterFromPersistentComponentStateValueProviderTests.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text;
 using System.Text.Json;
 using Microsoft.AspNetCore.Components.Infrastructure;
@@ -431,6 +432,146 @@ public async Task PersistenceFails_MultipleComponentsUseInvalidKeyTypes(object c
         Assert.Contains(sink.Writes, w => w is { LogLevel: LogLevel.Error } && w.EventId == new EventId(1000, "PersistenceCallbackError"));
     }
 
+    [Fact]
+    public async Task PersistAsync_CanPersistValueTypes_IntProperty()
+    {
+        // Arrange
+        var state = new Dictionary<string, byte[]>();
+        var store = new TestStore(state);
+        var persistenceManager = new ComponentStatePersistenceManager(
+            NullLogger<ComponentStatePersistenceManager>.Instance,
+            new ServiceCollection().BuildServiceProvider());
+
+        var renderer = new TestRenderer();
+        var component = new ValueTypeTestComponent { IntValue = 42 };
+        var componentStates = CreateComponentState(renderer, [(component, null)], null);
+        var componentState = componentStates.First();
+
+        // Create the provider and subscribe the component
+        var provider = new SupplyParameterFromPersistentComponentStateValueProvider(persistenceManager.State);
+        var cascadingParameterInfo = CreateCascadingParameterInfo(nameof(ValueTypeTestComponent.IntValue), typeof(int));
+        provider.Subscribe(componentState, cascadingParameterInfo);
+
+        // Act
+        await persistenceManager.PersistStateAsync(store, renderer);
+
+        // Assert
+        Assert.NotEmpty(store.State);
+
+        // Verify the value was persisted correctly
+        var newState = new PersistentComponentState(new Dictionary<string, byte[]>(), []);
+        newState.InitializeExistingState(store.State);
+
+        var key = SupplyParameterFromPersistentComponentStateValueProvider.ComputeKey(componentState, cascadingParameterInfo.PropertyName);
+        Assert.True(newState.TryTakeFromJson<int>(key, out var retrievedValue));
+        Assert.Equal(42, retrievedValue);
+    }
+
+    [Fact]
+    public async Task PersistAsync_CanPersistValueTypes_NullableIntProperty()
+    {
+        // Arrange
+        var state = new Dictionary<string, byte[]>();
+        var store = new TestStore(state);
+        var persistenceManager = new ComponentStatePersistenceManager(
+            NullLogger<ComponentStatePersistenceManager>.Instance,
+            new ServiceCollection().BuildServiceProvider());
+
+        var renderer = new TestRenderer();
+        var component = new ValueTypeTestComponent { NullableIntValue = 123 };
+        var componentStates = CreateComponentState(renderer, [(component, null)], null);
+        var componentState = componentStates.First();
+
+        // Create the provider and subscribe the component
+        var provider = new SupplyParameterFromPersistentComponentStateValueProvider(persistenceManager.State);
+        var cascadingParameterInfo = CreateCascadingParameterInfo(nameof(ValueTypeTestComponent.NullableIntValue), typeof(int?));
+        provider.Subscribe(componentState, cascadingParameterInfo);
+
+        // Act
+        await persistenceManager.PersistStateAsync(store, renderer);
+
+        // Assert
+        Assert.NotEmpty(store.State);
+
+        // Verify the value was persisted correctly
+        var newState = new PersistentComponentState(new Dictionary<string, byte[]>(), []);
+        newState.InitializeExistingState(store.State);
+
+        var key = SupplyParameterFromPersistentComponentStateValueProvider.ComputeKey(componentState, cascadingParameterInfo.PropertyName);
+        Assert.True(newState.TryTakeFromJson<int?>(key, out var retrievedValue));
+        Assert.Equal(123, retrievedValue);
+    }
+
+    [Fact]
+    public async Task PersistAsync_CanPersistValueTypes_TupleProperty()
+    {
+        // Arrange
+        var state = new Dictionary<string, byte[]>();
+        var store = new TestStore(state);
+        var persistenceManager = new ComponentStatePersistenceManager(
+            NullLogger<ComponentStatePersistenceManager>.Instance,
+            new ServiceCollection().BuildServiceProvider());
+
+        var renderer = new TestRenderer();
+        var component = new ValueTypeTestComponent { TupleValue = ("test", 456) };
+        var componentStates = CreateComponentState(renderer, [(component, null)], null);
+        var componentState = componentStates.First();
+
+        // Create the provider and subscribe the component
+        var provider = new SupplyParameterFromPersistentComponentStateValueProvider(persistenceManager.State);
+        var cascadingParameterInfo = CreateCascadingParameterInfo(nameof(ValueTypeTestComponent.TupleValue), typeof((string, int)));
+        provider.Subscribe(componentState, cascadingParameterInfo);
+
+        // Act
+        await persistenceManager.PersistStateAsync(store, renderer);
+
+        // Assert
+        Assert.NotEmpty(store.State);
+
+        // Verify the value was persisted correctly
+        var newState = new PersistentComponentState(new Dictionary<string, byte[]>(), []);
+        newState.InitializeExistingState(store.State);
+
+        var key = SupplyParameterFromPersistentComponentStateValueProvider.ComputeKey(componentState, cascadingParameterInfo.PropertyName);
+        Assert.True(newState.TryTakeFromJson<(string, int)>(key, out var retrievedValue));
+        Assert.Equal(("test", 456), retrievedValue);
+    }
+
+    [Fact]
+    public async Task PersistAsync_CanPersistValueTypes_NullableTupleProperty()
+    {
+        // Arrange
+        var state = new Dictionary<string, byte[]>();
+        var store = new TestStore(state);
+        var persistenceManager = new ComponentStatePersistenceManager(
+            NullLogger<ComponentStatePersistenceManager>.Instance,
+            new ServiceCollection().BuildServiceProvider());
+
+        var renderer = new TestRenderer();
+        var component = new ValueTypeTestComponent { NullableTupleValue = ("test2", 789) };
+        var componentStates = CreateComponentState(renderer, [(component, null)], null);
+        var componentState = componentStates.First();
+
+        // Create the provider and subscribe the component
+        var provider = new SupplyParameterFromPersistentComponentStateValueProvider(persistenceManager.State);
+        var cascadingParameterInfo = CreateCascadingParameterInfo(nameof(ValueTypeTestComponent.NullableTupleValue), typeof((string, int)?));
+        provider.Subscribe(componentState, cascadingParameterInfo);
+
+        // Act
+        await persistenceManager.PersistStateAsync(store, renderer);
+
+        // Assert
+        Assert.NotEmpty(store.State);
+
+        // Verify the value was persisted correctly
+        var newState = new PersistentComponentState(new Dictionary<string, byte[]>(), []);
+        newState.InitializeExistingState(store.State);
+
+        var key = SupplyParameterFromPersistentComponentStateValueProvider.ComputeKey(componentState, cascadingParameterInfo.PropertyName);
+        Assert.True(newState.TryTakeFromJson<(string, int)?>(key, out var retrievedValue));
+        Assert.Equal(("test2", 789), retrievedValue);
+    }
+
     private static void InitializeState(PersistentComponentState state, List<(ComponentState componentState, string propertyName, string value)> items)
     {
         var dictionary = new Dictionary<string, byte[]>();
@@ -452,7 +593,7 @@ private static CascadingParameterInfo CreateCascadingParameterInfo(string proper
 
     private static List<ComponentState> CreateComponentState(
         TestRenderer renderer,
-        List<(TestComponent, object)> components,
+        List<(IComponent, object)> components,
         ParentComponent parentComponent = null)
     {
         var i = 1;
@@ -464,7 +605,20 @@ private static List<ComponentState> CreateComponentState(
             var componentState = new ComponentState(renderer, i++, component, parentComponentState);
             if (currentRenderTree != null && key != null)
             {
-                currentRenderTree.OpenComponent<TestComponent>(0);
+                // Open component based on the actual component type
+                if (component is TestComponent)
+                {
+                    currentRenderTree.OpenComponent<TestComponent>(0);
+                }
+                else if (component is ValueTypeTestComponent)
+                {
+                    currentRenderTree.OpenComponent<ValueTypeTestComponent>(0);
+                }
+                else
+                {
+                    currentRenderTree.OpenComponent<IComponent>(0);
+                }
+                
                 var frames = currentRenderTree.GetFrames();
                 frames.Array[frames.Count - 1].ComponentStateField = componentState;
                 if (key != null)
@@ -497,6 +651,24 @@ private class TestComponent : IComponent
         public Task SetParametersAsync(ParameterView parameters) => throw new NotImplementedException();
     }
 
+    private class ValueTypeTestComponent : IComponent
+    {
+        [SupplyParameterFromPersistentComponentState]
+        public int IntValue { get; set; }
+
+        [SupplyParameterFromPersistentComponentState]
+        public int? NullableIntValue { get; set; }
+
+        [SupplyParameterFromPersistentComponentState]
+        public (string, int) TupleValue { get; set; }
+
+        [SupplyParameterFromPersistentComponentState]
+        public (string, int)? NullableTupleValue { get; set; }
+
+        public void Attach(RenderHandle renderHandle) => throw new NotImplementedException();
+        public Task SetParametersAsync(ParameterView parameters) => throw new NotImplementedException();
+    }
+
     private class TestStore(Dictionary<string, byte[]> initialState) : IPersistentComponentStateStore
     {
         public IDictionary<string, byte[]> State { get; set; } = initialState;