Fix PersistentState to throw clear error for non-public properties

Co-authored-by: javiercn <[email protected]>

Author: Copilot

src/Components/Components/src/PersistentState/PersistentValueProviderComponentSubscription.cs

@@ -233,10 +233,28 @@ private static PropertyGetter PropertyGetterFactory((Type type, string propertyN
         {
             throw new InvalidOperationException($"Property {propertyName} not found on type {type.FullName}");
         }
+
+        // Check if the property is public
+        if (propertyInfo.GetMethod == null || !propertyInfo.GetMethod.IsPublic)
+        {
+            throw new InvalidOperationException(
+                $"The property '{propertyName}' on component type '{type.FullName}' cannot be used with PersistentState because it is not public. Properties with PersistentState must be public.");
+        }
+
         return new PropertyGetter(type, propertyInfo);
 
         static PropertyInfo? GetPropertyInfo([DynamicallyAccessedMembers(LinkerFlags.Component)] Type type, string propertyName)
-            => type.GetProperty(propertyName);
+        {
+            // First try to find the property with public access only (for performance in the common case)
+            var publicProperty = type.GetProperty(propertyName);
+            if (publicProperty != null)
+            {
+                return publicProperty;
+            }
+
+            // If not found as public, try with all flags to see if it exists as private/protected
+            return type.GetProperty(propertyName, ComponentProperties.BindablePropertyFlags);
+        }
     }
 
     private static partial class Log

src/Components/Components/test/PersistentValueProviderComponentSubscriptionTests.cs

@@ -623,4 +623,90 @@ private class TestStore(IDictionary<string, byte[]> state) : IPersistentComponen
         public Task<IDictionary<string, byte[]>> GetPersistedStateAsync() => Task.FromResult(state);
         public Task PersistStateAsync(IReadOnlyDictionary<string, byte[]> state) => throw new NotImplementedException();
     }
+
+    private class ComponentWithPrivateProperty : IComponent
+    {
+        [PersistentState]
+        private string PrivateValue { get; set; } = "initial";
+
+        public void Attach(RenderHandle renderHandle) => throw new NotImplementedException();
+        public Task SetParametersAsync(ParameterView parameters) => throw new NotImplementedException();
+    }
+
+    private class ComponentWithPrivateGetter : IComponent
+    {
+        [PersistentState]
+        public string PropertyWithPrivateGetter { private get; set; } = "initial";
+
+        public void Attach(RenderHandle renderHandle) => throw new NotImplementedException();
+        public Task SetParametersAsync(ParameterView parameters) => throw new NotImplementedException();
+    }
+
+    [Fact]
+    public void Constructor_ThrowsClearException_ForPrivateProperty()
+    {
+        // Arrange
+        var state = new PersistentComponentState(new Dictionary<string, byte[]>(), [], []);
+        state.InitializeExistingState(new Dictionary<string, byte[]>(), RestoreContext.InitialValue);
+        var renderer = new TestRenderer();
+        var component = new ComponentWithPrivateProperty();
+        var componentState = CreateComponentState(renderer, component, null, null);
+        var cascadingParameterInfo = CreateCascadingParameterInfo("PrivateValue", typeof(string));
+        var serviceProvider = new ServiceCollection().BuildServiceProvider();
+        var logger = NullLogger.Instance;
+
+        // Act & Assert
+        var exception = Assert.Throws<InvalidOperationException>(() =>
+            new PersistentValueProviderComponentSubscription(
+                state, componentState, cascadingParameterInfo, serviceProvider, logger));
+
+        // Should throw a clear error about non-public properties, not "Property not found"
+        Assert.Contains("not public", exception.Message);
+        Assert.Contains("PersistentState", exception.Message);
+        Assert.DoesNotContain("not found", exception.Message);
+    }
+
+    [Fact]
+    public void Constructor_ThrowsClearException_ForPrivateGetter()
+    {
+        // Arrange
+        var state = new PersistentComponentState(new Dictionary<string, byte[]>(), [], []);
+        state.InitializeExistingState(new Dictionary<string, byte[]>(), RestoreContext.InitialValue);
+        var renderer = new TestRenderer();
+        var component = new ComponentWithPrivateGetter();
+        var componentState = CreateComponentState(renderer, component, null, null);
+        var cascadingParameterInfo = CreateCascadingParameterInfo(nameof(ComponentWithPrivateGetter.PropertyWithPrivateGetter), typeof(string));
+        var serviceProvider = new ServiceCollection().BuildServiceProvider();
+        var logger = NullLogger.Instance;
+
+        // Act & Assert
+        var exception = Assert.Throws<InvalidOperationException>(() =>
+            new PersistentValueProviderComponentSubscription(
+                state, componentState, cascadingParameterInfo, serviceProvider, logger));
+
+        // Should throw a clear error about non-public getter
+        Assert.Contains("not public", exception.Message);
+        Assert.Contains("PersistentState", exception.Message);
+    }
+
+    [Fact]
+    public void Constructor_WorksCorrectly_ForPublicProperty()
+    {
+        // Arrange
+        var state = new PersistentComponentState(new Dictionary<string, byte[]>(), [], []);
+        state.InitializeExistingState(new Dictionary<string, byte[]>(), RestoreContext.InitialValue);
+        var renderer = new TestRenderer();
+        var component = new TestComponent { State = "test-value" };
+        var componentState = CreateComponentState(renderer, component, null, null);
+        var cascadingParameterInfo = CreateCascadingParameterInfo(nameof(TestComponent.State), typeof(string));
+        var serviceProvider = new ServiceCollection().BuildServiceProvider();
+        var logger = NullLogger.Instance;
+
+        // Act & Assert - Should not throw
+        var subscription = new PersistentValueProviderComponentSubscription(
+            state, componentState, cascadingParameterInfo, serviceProvider, logger);
+
+        Assert.NotNull(subscription);
+        subscription.Dispose();
+    }
 }