Convert IPersistentComponentStateSerializer<T> interface to abstract class PersistentComponentStateSerializer<T>

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

Author: Copilot

src/Components/Components/src/IPersistentComponentStateSerializer.cs

@@ -5,7 +5,7 @@
 
 namespace Microsoft.AspNetCore.Components;
 
-public interface IPersistentComponentStateSerializer
+internal interface IPersistentComponentStateSerializer
 {
     Task PersistAsync(Type type, object value, IBufferWriter<byte> writer);
     object Restore(Type type, ReadOnlySequence<byte> data);

src/Components/Components/src/IPersistentComponentStateSerializerOfT.cs renamed to src/Components/Components/src/PersistentComponentStateSerializer.cs

@@ -9,23 +9,23 @@ namespace Microsoft.AspNetCore.Components;
 /// 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> : IPersistentComponentStateSerializer
+public abstract class PersistentComponentStateSerializer<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>
     /// <returns>A task that represents the asynchronous serialization operation.</returns>
-    Task PersistAsync(T value, IBufferWriter<byte> writer);
+    public abstract Task PersistAsync(T value, IBufferWriter<byte> writer);
 
     /// <summary>
     /// Deserializes a value of type <typeparamref name="T"/> from the provided <paramref name="data"/>.
     /// This method must be synchronous to avoid UI tearing during component state restoration.
     /// </summary>
     /// <param name="data">The serialized data to deserialize.</param>
     /// <returns>The deserialized value.</returns>
-    T Restore(ReadOnlySequence<byte> data);
+    public abstract T Restore(ReadOnlySequence<byte> data);
 
     /// <summary>
     /// Explicit interface implementation for non-generic serialization.

src/Components/Components/src/PersistentStateValueProvider.cs

@@ -106,10 +106,10 @@ private static PropertyGetter ResolvePropertyGetter(Type type, string propertyNa
 
     private IPersistentComponentStateSerializer? SerializerFactory(Type type)
     {
-        var serializerType = typeof(IPersistentComponentStateSerializer<>).MakeGenericType(type);
+        var serializerType = typeof(PersistentComponentStateSerializer<>).MakeGenericType(type);
         var serializer = serviceProvider.GetService(serializerType);
 
-        // The generic interface now inherits from the internal interface, so we can cast directly
+        // The generic class now inherits from the internal interface, so we can cast directly
         return serializer as IPersistentComponentStateSerializer;
     }
 
@@ -331,7 +331,7 @@ private static bool IsSerializableKey(object key)
     /// <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)
+    internal async Task PersistAsync<TValue>(string key, TValue instance, PersistentComponentStateSerializer<TValue> serializer)
     {
         ArgumentNullException.ThrowIfNull(key);
         ArgumentNullException.ThrowIfNull(serializer);
@@ -351,7 +351,7 @@ internal async Task PersistAsync<TValue>(string key, TValue instance, IPersisten
     /// <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)
+    internal bool TryTake<TValue>(string key, PersistentComponentStateSerializer<TValue> serializer, [MaybeNullWhen(false)] out TValue instance)
     {
         ArgumentNullException.ThrowIfNull(key);
         ArgumentNullException.ThrowIfNull(serializer);

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

@@ -16,12 +16,10 @@ 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
+Microsoft.AspNetCore.Components.PersistentComponentStateSerializer<T>
+Microsoft.AspNetCore.Components.PersistentComponentStateSerializer<T>.PersistentComponentStateSerializer() -> void
+abstract Microsoft.AspNetCore.Components.PersistentComponentStateSerializer<T>.PersistAsync(T value, System.Buffers.IBufferWriter<byte>! writer) -> System.Threading.Tasks.Task!
+abstract Microsoft.AspNetCore.Components.PersistentComponentStateSerializer<T>.Restore(System.Buffers.ReadOnlySequence<byte> data) -> T
 static Microsoft.AspNetCore.Components.Infrastructure.RegisterPersistentComponentStateServiceCollectionExtensions.AddPersistentServiceRegistration<TService>(Microsoft.Extensions.DependencyInjection.IServiceCollection! services, Microsoft.AspNetCore.Components.IComponentRenderMode! componentRenderMode) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!
 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!

src/Components/Components/test/IPersistentComponentStateSerializerTests.cs

@@ -62,16 +62,16 @@ public void TryTake_CanUseCustomSerializer()
         Assert.Equal(customData, retrievedValue);
     }
 
-    private class TestStringSerializer : IPersistentComponentStateSerializer<string>
+    private class TestStringSerializer : PersistentComponentStateSerializer<string>
     {
-        public Task PersistAsync(string value, IBufferWriter<byte> writer)
+        public override Task PersistAsync(string value, IBufferWriter<byte> writer)
         {
             var bytes = Encoding.UTF8.GetBytes(value);
             writer.Write(bytes);
             return Task.CompletedTask;
         }
 
-        public string Restore(ReadOnlySequence<byte> data)
+        public override string Restore(ReadOnlySequence<byte> data)
         {
             var bytes = data.ToArray();
             return Encoding.UTF8.GetString(bytes);

src/Components/test/testassets/Components.TestServer/RazorComponentEndpointsStartup.cs

@@ -67,7 +67,7 @@ public void ConfigureServices(IServiceCollection services)
         services.AddScoped<InteractiveAutoService>();
 
         // Register custom serializer for E2E testing of persistent component state serialization extensibility
-        services.AddSingleton<IPersistentComponentStateSerializer<int>, CustomIntSerializer>();
+        services.AddSingleton<PersistentComponentStateSerializer<int>, CustomIntSerializer>();
 
         services.AddHttpContextAccessor();
         services.AddSingleton<AsyncOperationService>();

src/Components/test/testassets/Components.WasmMinimal/Program.cs

@@ -17,7 +17,7 @@
 builder.Services.AddSingleton<InteractiveServerService>();
 
 // Register custom serializer for persistent component state
-builder.Services.AddSingleton<IPersistentComponentStateSerializer<int>, CustomIntSerializer>();
+builder.Services.AddSingleton<PersistentComponentStateSerializer<int>, CustomIntSerializer>();
 
 builder.Services.AddCascadingAuthenticationState();
 

src/Components/test/testassets/TestContentPackage/CustomIntSerializer.cs

@@ -11,17 +11,17 @@ namespace TestContentPackage;
 /// A custom serializer for int values that uses a custom format to test serialization extensibility.
 /// This serializer prefixes integer values with "CUSTOM:" to clearly distinguish them from JSON serialization.
 /// </summary>
-public class CustomIntSerializer : IPersistentComponentStateSerializer<int>
+public class CustomIntSerializer : PersistentComponentStateSerializer<int>
 {
-    public Task PersistAsync(int value, IBufferWriter<byte> writer)
+    public override Task PersistAsync(int value, IBufferWriter<byte> writer)
     {
         var customFormat = $"CUSTOM:{value}";
         var bytes = Encoding.UTF8.GetBytes(customFormat);
         writer.Write(bytes);
         return Task.CompletedTask;
     }
 
-    public int Restore(ReadOnlySequence<byte> data)
+    public override int Restore(ReadOnlySequence<byte> data)
     {
         var bytes = data.ToArray();
         var text = Encoding.UTF8.GetString(bytes);