Implement interface architecture changes for custom serializers per feedback

- Remove CancellationToken from IPersistentComponentStateSerializer interface
- Create internal IPersistentComponentStateSerializer base interface with Type parameter
- Add default interface implementations for type safety
- Add serializer caching with ConcurrentDictionary
- Move serializer resolution outside of lambda for better performance
- Add PersistAsBytes and TryTakeBytes methods for raw byte operations
- Update PublicAPI to reflect interface changes

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

Author: Copilot

src/Components/Components/src/IPersistentComponentStateSerializer.cs

@@ -5,20 +5,43 @@
 
 namespace Microsoft.AspNetCore.Components;
 
+/// <summary>
+/// Provides custom serialization logic for persistent component state values.
+/// </summary>
+public interface IPersistentComponentStateSerializer
+{
+    /// <summary>
+    /// Serializes the provided <paramref name="value"/> and writes it to the <paramref name="writer"/>.
+    /// </summary>
+    /// <param name="type">The type of the value to serialize.</param>
+    /// <param name="value">The value to serialize.</param>
+    /// <param name="writer">The buffer writer to write the serialized data to.</param>
+    /// <returns>A task that represents the asynchronous serialization operation.</returns>
+    Task PersistAsync(Type type, object value, IBufferWriter<byte> writer);
+
+    /// <summary>
+    /// Deserializes a value from the provided <paramref name="data"/>.
+    /// This method must be synchronous to avoid UI tearing during component state restoration.
+    /// </summary>
+    /// <param name="type">The type of the value to deserialize.</param>
+    /// <param name="data">The serialized data to deserialize.</param>
+    /// <returns>The deserialized value.</returns>
+    object Restore(Type type, ReadOnlySequence<byte> data);
+}
+
 /// <summary>
 /// Provides custom serialization logic for persistent component state values of type <typeparamref name="T"/>.
 /// </summary>
 /// <typeparam name="T">The type of the value to serialize.</typeparam>
-public interface IPersistentComponentStateSerializer<T>
+public interface IPersistentComponentStateSerializer<T> : IPersistentComponentStateSerializer
 {
     /// <summary>
     /// Serializes the provided <paramref name="value"/> and writes it to the <paramref name="writer"/>.
     /// </summary>
     /// <param name="value">The value to serialize.</param>
     /// <param name="writer">The buffer writer to write the serialized data to.</param>
-    /// <param name="cancellationToken">A cancellation token that can be used to cancel the serialization operation.</param>
     /// <returns>A task that represents the asynchronous serialization operation.</returns>
-    Task PersistAsync(T value, IBufferWriter<byte> writer, CancellationToken cancellationToken);
+    Task PersistAsync(T value, IBufferWriter<byte> writer);
 
     /// <summary>
     /// Deserializes a value of type <typeparamref name="T"/> from the provided <paramref name="data"/>.
@@ -27,4 +50,16 @@ public interface IPersistentComponentStateSerializer<T>
     /// <param name="data">The serialized data to deserialize.</param>
     /// <returns>The deserialized value.</returns>
     T Restore(ReadOnlySequence<byte> data);
+
+    /// <summary>
+    /// Default implementation of the non-generic PersistAsync method.
+    /// </summary>
+    Task IPersistentComponentStateSerializer.PersistAsync(Type type, object value, IBufferWriter<byte> writer)
+        => PersistAsync((T)value, writer);
+
+    /// <summary>
+    /// Default implementation of the non-generic Restore method.
+    /// </summary>
+    object IPersistentComponentStateSerializer.Restore(Type type, ReadOnlySequence<byte> data)
+        => Restore(data)!;
 }

src/Components/Components/src/PersistentComponentState.cs

@@ -111,15 +111,36 @@ internal void PersistAsJson(string key, object instance, [DynamicallyAccessedMem
         _currentState.Add(key, JsonSerializer.SerializeToUtf8Bytes(instance, type, JsonSerializerOptionsProvider.Options));
     }
 
+    /// <summary>
+    /// Persists the provided byte array under the given key.
+    /// </summary>
+    /// <param name="key">The key to use to persist the state.</param>
+    /// <param name="data">The byte array to persist.</param>
+    internal void PersistAsBytes(string key, byte[] data)
+    {
+        ArgumentNullException.ThrowIfNull(key);
+
+        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}'");
+        }
+
+        _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>
-    /// <param name="cancellationToken">A cancellation token that can be used to cancel the serialization operation.</param>
-    internal async Task PersistAsync<TValue>(string key, TValue instance, IPersistentComponentStateSerializer<TValue> serializer, CancellationToken cancellationToken = default)
+    internal async Task PersistAsync<TValue>(string key, TValue instance, IPersistentComponentStateSerializer<TValue> serializer)
     {
         ArgumentNullException.ThrowIfNull(key);
         ArgumentNullException.ThrowIfNull(serializer);
@@ -135,7 +156,7 @@ internal async Task PersistAsync<TValue>(string key, TValue instance, IPersisten
         }
 
         using var writer = new PooledArrayBufferWriter<byte>();
-        await serializer.PersistAsync(instance, writer, cancellationToken);
+        await serializer.PersistAsync(instance, writer);
         _currentState.Add(key, writer.WrittenMemory.ToArray());
     }
 
@@ -212,6 +233,19 @@ internal bool TryTake<TValue>(string key, IPersistentComponentStateSerializer<TV
         }
     }
 
+    /// <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"/>
+    /// and removed from the <see cref="PersistentComponentState"/>.
+    /// </summary>
+    /// <param name="key">The key used to persist the data.</param>
+    /// <param name="data">The persisted raw bytes.</param>
+    /// <returns><c>true</c> if the state was found; <c>false</c> otherwise.</returns>
+    internal bool TryTakeBytes(string key, [MaybeNullWhen(false)] out byte[]? data)
+    {
+        return TryTake(key, out data);
+    }
+
     private bool TryTake(string key, out byte[]? value)
     {
         ArgumentNullException.ThrowIfNull(key);

src/Components/Components/src/PersistentStateValueProvider.cs

@@ -19,6 +19,7 @@ internal sealed class PersistentStateValueProvider(PersistentComponentState stat
 {
     private static readonly ConcurrentDictionary<(string, string, string), byte[]> _keyCache = new();
     private static readonly ConcurrentDictionary<(Type, string), PropertyGetter> _propertyGetterCache = new();
+    private static readonly ConcurrentDictionary<Type, IPersistentComponentStateSerializer?> _serializerCache = new();
 
     private readonly Dictionary<ComponentState, PersistingComponentStateSubscription> _subscriptions = [];
 
@@ -43,19 +44,16 @@ public bool CanSupplyValue(in CascadingParameterInfo parameterInfo)
         var storageKey = ComputeKey(componentState, parameterInfo.PropertyName);
 
         // Try to get a custom serializer for this type first
-        var serializerType = typeof(IPersistentComponentStateSerializer<>).MakeGenericType(parameterInfo.PropertyType);
-        var customSerializer = serviceProvider.GetService(serializerType);
+        var customSerializer = ResolveSerializer(parameterInfo.PropertyType);
 
         if (customSerializer != null)
         {
-            // Use reflection to call the generic TryTake method with the custom serializer
-            var tryTakeMethod = typeof(PersistentComponentState).GetMethod(nameof(PersistentComponentState.TryTake), BindingFlags.Instance | BindingFlags.NonPublic, [typeof(string), serializerType, parameterInfo.PropertyType.MakeByRefType()]);
-            if (tryTakeMethod != null)
+            if (state.TryTakeBytes(storageKey, out var data))
             {
-                var parameters = new object?[] { storageKey, customSerializer, null };
-                var success = (bool)tryTakeMethod.Invoke(state, parameters)!;
-                return success ? parameters[2] : null;
+                var sequence = new ReadOnlySequence<byte>(data!);
+                return customSerializer.Restore(parameterInfo.PropertyType, sequence);
             }
+            return null;
         }
 
         // Fallback to JSON serialization
@@ -69,6 +67,10 @@ public void Subscribe(ComponentState subscriber, in CascadingParameterInfo param
     {
         var propertyName = parameterInfo.PropertyName;
         var propertyType = parameterInfo.PropertyType;
+        
+        // Resolve serializer outside the lambda
+        var customSerializer = ResolveSerializer(propertyType);
+        
         _subscriptions[subscriber] = state.RegisterOnPersisting(async () =>
             {
                 var storageKey = ComputeKey(subscriber, propertyName);
@@ -79,20 +81,12 @@ public void Subscribe(ComponentState subscriber, in CascadingParameterInfo param
                     return;
                 }
 
-                // Try to get a custom serializer for this type first
-                var serializerType = typeof(IPersistentComponentStateSerializer<>).MakeGenericType(propertyType);
-                var customSerializer = serviceProvider.GetService(serializerType);
-                
                 if (customSerializer != null)
                 {
-                    // Use reflection to call the generic PersistAsync method with the custom serializer
-                    var persistMethod = typeof(PersistentComponentState).GetMethod(nameof(PersistentComponentState.PersistAsync), BindingFlags.Instance | BindingFlags.NonPublic, [typeof(string), propertyType, serializerType, typeof(CancellationToken)]);
-                    if (persistMethod != null)
-                    {
-                        var task = (Task)persistMethod.Invoke(state, [storageKey, property, customSerializer, CancellationToken.None])!;
-                        await task;
-                        return;
-                    }
+                    using var writer = new PooledArrayBufferWriter<byte>();
+                    await customSerializer.PersistAsync(propertyType, property, writer);
+                    state.PersistAsBytes(storageKey, writer.WrittenMemory.ToArray());
+                    return;
                 }
 
                 // Fallback to JSON serialization
@@ -105,6 +99,28 @@ private static PropertyGetter ResolvePropertyGetter(Type type, string propertyNa
         return _propertyGetterCache.GetOrAdd((type, propertyName), PropertyGetterFactory);
     }
 
+    private IPersistentComponentStateSerializer? ResolveSerializer(Type type)
+    {
+        if (_serializerCache.TryGetValue(type, out var cached))
+        {
+            return cached;
+        }
+
+        var serializer = SerializerFactory(type);
+        if (serializer != null)
+        {
+            _serializerCache.TryAdd(type, serializer);
+        }
+        return serializer;
+    }
+
+    private IPersistentComponentStateSerializer? SerializerFactory(Type type)
+    {
+        var serializerType = typeof(IPersistentComponentStateSerializer<>).MakeGenericType(type);
+        var serializer = serviceProvider.GetService(serializerType);
+        return serializer as IPersistentComponentStateSerializer;
+    }
+
     [UnconditionalSuppressMessage(
     "Trimming",
     "IL2077:Target parameter argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The source field does not have matching annotations.",

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

@@ -21,6 +21,9 @@ static Microsoft.AspNetCore.Components.Infrastructure.ComponentsMetricsServiceCo
 static Microsoft.AspNetCore.Components.Infrastructure.ComponentsMetricsServiceCollectionExtensions.AddComponentsTracing(Microsoft.Extensions.DependencyInjection.IServiceCollection! services) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!
 static Microsoft.AspNetCore.Components.Infrastructure.PersistentStateProviderServiceCollectionExtensions.AddSupplyValueFromPersistentComponentStateProvider(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!
 virtual Microsoft.AspNetCore.Components.Rendering.ComponentState.GetComponentKey() -> object?
+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.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!
+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

@@ -59,7 +59,7 @@ public void TryTake_CanUseCustomSerializer()
 
     private class TestStringSerializer : IPersistentComponentStateSerializer<string>
     {
-        public Task PersistAsync(string value, IBufferWriter<byte> writer, CancellationToken cancellationToken)
+        public Task PersistAsync(string value, IBufferWriter<byte> writer)
         {
             var bytes = Encoding.UTF8.GetBytes(value);
             writer.Write(bytes);