Move PersistAsync and TryTake methods to PersistentStateValueProvider per code review feedback

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

Author: Copilot

src/Components/Components/src/IPersistentComponentStateSerializer.cs

@@ -8,7 +8,7 @@ namespace Microsoft.AspNetCore.Components;
 /// <summary>
 /// Provides custom serialization logic for persistent component state values.
 /// </summary>
-internal interface IPersistentComponentStateSerializer
+public interface IPersistentComponentStateSerializer
 {
     /// <summary>
     /// Serializes the provided <paramref name="value"/> and writes it to the <paramref name="writer"/>.

src/Components/Components/src/PersistentComponentState.cs

@@ -1,7 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Buffers;
 using System.Diagnostics.CodeAnalysis;
 using System.Text.Json;
 using static Microsoft.AspNetCore.Internal.LinkerFlags;
@@ -133,33 +132,6 @@ internal void PersistAsBytes(string key, byte[] data)
         _currentState.Add(key, data);
     }
 
-    /// <summary>
-    /// Serializes <paramref name="instance"/> using the provided <paramref name="serializer"/> and persists it under the given <paramref name="key"/>.
-    /// </summary>
-    /// <typeparam name="TValue">The <paramref name="instance"/> type.</typeparam>
-    /// <param name="key">The key to use to persist the state.</param>
-    /// <param name="instance">The instance to persist.</param>
-    /// <param name="serializer">The custom serializer to use for serialization.</param>
-    internal async Task PersistAsync<TValue>(string key, TValue instance, IPersistentComponentStateSerializer<TValue> serializer)
-    {
-        ArgumentNullException.ThrowIfNull(key);
-        ArgumentNullException.ThrowIfNull(serializer);
-
-        if (!PersistingState)
-        {
-            throw new InvalidOperationException("Persisting state is only allowed during an OnPersisting callback.");
-        }
-
-        if (_currentState.ContainsKey(key))
-        {
-            throw new ArgumentException($"There is already a persisted object under the same key '{key}'");
-        }
-
-        using var writer = new PooledArrayBufferWriter<byte>();
-        await serializer.PersistAsync(instance, writer);
-        _currentState.Add(key, writer.WrittenMemory.ToArray());
-    }
-
     /// <summary>
     /// Tries to retrieve the persisted state as JSON with the given <paramref name="key"/> and deserializes it into an
     /// instance of type <typeparamref name="TValue"/>.
@@ -205,34 +177,6 @@ internal bool TryTakeFromJson(string key, [DynamicallyAccessedMembers(JsonSerial
         }
     }
 
-    /// <summary>
-    /// Tries to retrieve the persisted state with the given <paramref name="key"/> and deserializes it using the provided <paramref name="serializer"/> into an
-    /// instance of type <typeparamref name="TValue"/>.
-    /// When the key is present, the state is successfully returned via <paramref name="instance"/>
-    /// and removed from the <see cref="PersistentComponentState"/>.
-    /// </summary>
-    /// <param name="key">The key used to persist the instance.</param>
-    /// <param name="serializer">The custom serializer to use for deserialization.</param>
-    /// <param name="instance">The persisted instance.</param>
-    /// <returns><c>true</c> if the state was found; <c>false</c> otherwise.</returns>
-    internal bool TryTake<TValue>(string key, IPersistentComponentStateSerializer<TValue> serializer, [MaybeNullWhen(false)] out TValue instance)
-    {
-        ArgumentNullException.ThrowIfNull(key);
-        ArgumentNullException.ThrowIfNull(serializer);
-
-        if (TryTake(key, out var data))
-        {
-            var sequence = new ReadOnlySequence<byte>(data!);
-            instance = serializer.Restore(sequence);
-            return true;
-        }
-        else
-        {
-            instance = default;
-            return false;
-        }
-    }
-
     /// <summary>
     /// Tries to retrieve the persisted state as raw bytes with the given <paramref name="key"/>.
     /// When the key is present, the raw bytes are successfully returned via <paramref name="data"/>

src/Components/Components/src/PersistentStateValueProvider.cs

@@ -321,4 +321,49 @@ private static bool IsSerializableKey(object key)
 
         return result;
     }
+
+    /// <summary>
+    /// Serializes <paramref name="instance"/> using the provided <paramref name="serializer"/> and persists it under the given <paramref name="key"/>.
+    /// </summary>
+    /// <typeparam name="TValue">The <paramref name="instance"/> type.</typeparam>
+    /// <param name="key">The key to use to persist the state.</param>
+    /// <param name="instance">The instance to persist.</param>
+    /// <param name="serializer">The custom serializer to use for serialization.</param>
+    internal async Task PersistAsync<TValue>(string key, TValue instance, IPersistentComponentStateSerializer<TValue> serializer)
+    {
+        ArgumentNullException.ThrowIfNull(key);
+        ArgumentNullException.ThrowIfNull(serializer);
+
+        using var writer = new PooledArrayBufferWriter<byte>();
+        await serializer.PersistAsync(instance, writer);
+        state.PersistAsBytes(key, writer.WrittenMemory.ToArray());
+    }
+
+    /// <summary>
+    /// Tries to retrieve the persisted state with the given <paramref name="key"/> and deserializes it using the provided <paramref name="serializer"/> into an
+    /// instance of type <typeparamref name="TValue"/>.
+    /// When the key is present, the state is successfully returned via <paramref name="instance"/>
+    /// and removed from the <see cref="PersistentComponentState"/>.
+    /// </summary>
+    /// <param name="key">The key used to persist the instance.</param>
+    /// <param name="serializer">The custom serializer to use for deserialization.</param>
+    /// <param name="instance">The persisted instance.</param>
+    /// <returns><c>true</c> if the state was found; <c>false</c> otherwise.</returns>
+    internal bool TryTake<TValue>(string key, IPersistentComponentStateSerializer<TValue> serializer, [MaybeNullWhen(false)] out TValue instance)
+    {
+        ArgumentNullException.ThrowIfNull(key);
+        ArgumentNullException.ThrowIfNull(serializer);
+
+        if (state.TryTakeBytes(key, out var data))
+        {
+            var sequence = new ReadOnlySequence<byte>(data!);
+            instance = serializer.Restore(sequence);
+            return true;
+        }
+        else
+        {
+            instance = default;
+            return false;
+        }
+    }
 }

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

@@ -16,6 +16,9 @@ Microsoft.AspNetCore.Components.Infrastructure.RegisterPersistentComponentStateS
 Microsoft.AspNetCore.Components.PersistentStateAttribute
 Microsoft.AspNetCore.Components.PersistentStateAttribute.PersistentStateAttribute() -> void
 Microsoft.AspNetCore.Components.Infrastructure.PersistentStateProviderServiceCollectionExtensions
+Microsoft.AspNetCore.Components.IPersistentComponentStateSerializer
+Microsoft.AspNetCore.Components.IPersistentComponentStateSerializer.PersistAsync(System.Type! type, object! value, System.Buffers.IBufferWriter<byte>! writer) -> System.Threading.Tasks.Task!
+Microsoft.AspNetCore.Components.IPersistentComponentStateSerializer.Restore(System.Type! type, System.Buffers.ReadOnlySequence<byte> data) -> object!
 Microsoft.AspNetCore.Components.IPersistentComponentStateSerializer<T>
 Microsoft.AspNetCore.Components.IPersistentComponentStateSerializer<T>.PersistAsync(T value, System.Buffers.IBufferWriter<byte>! writer) -> System.Threading.Tasks.Task!
 Microsoft.AspNetCore.Components.IPersistentComponentStateSerializer<T>.Restore(System.Buffers.ReadOnlySequence<byte> data) -> T

src/Components/Components/test/IPersistentComponentStateSerializerTests.cs

@@ -17,22 +17,25 @@ public async Task PersistAsync_CanUseCustomSerializer()
         // Arrange
         var currentState = new Dictionary<string, byte[]>();
         var state = new PersistentComponentState(currentState, []);
+        var serviceProvider = new ServiceCollection().BuildServiceProvider();
+        var stateValueProvider = new PersistentStateValueProvider(state, serviceProvider);
         var customSerializer = new TestStringSerializer();
         var testValue = "Hello, World!";
 
         state.PersistingState = true;
 
         // Act
-        await state.PersistAsync("test-key", testValue, customSerializer);
+        await stateValueProvider.PersistAsync("test-key", testValue, customSerializer);
 
         // Assert
         state.PersistingState = false;
 
         // Simulate the state transfer that happens between persist and restore phases
         var newState = new PersistentComponentState(new Dictionary<string, byte[]>(), []);
         newState.InitializeExistingState(currentState);
+        var newStateValueProvider = new PersistentStateValueProvider(newState, serviceProvider);
 
-        Assert.True(newState.TryTake("test-key", customSerializer, out var retrievedValue));
+        Assert.True(newStateValueProvider.TryTake("test-key", customSerializer, out var retrievedValue));
         Assert.Equal(testValue, retrievedValue);
     }
 
@@ -47,10 +50,12 @@ public void TryTake_CanUseCustomSerializer()
         var state = new PersistentComponentState(new Dictionary<string, byte[]>(), []);
         state.InitializeExistingState(existingState);
 
+        var serviceProvider = new ServiceCollection().BuildServiceProvider();
+        var stateValueProvider = new PersistentStateValueProvider(state, serviceProvider);
         var customSerializer = new TestStringSerializer();
 
         // Act
-        var success = state.TryTake("test-key", customSerializer, out var retrievedValue);
+        var success = stateValueProvider.TryTake("test-key", customSerializer, out var retrievedValue);
 
         // Assert
         Assert.True(success);