Make PersistAsync method void returning instead of Task returning

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

Author: Copilot

src/Components/Components/src/IPersistentComponentStateSerializer.cs

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

src/Components/Components/src/PersistentComponentStateSerializer.cs

@@ -16,8 +16,7 @@ public abstract class PersistentComponentStateSerializer<T> : IPersistentCompone
     /// </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>
-    public abstract Task PersistAsync(T value, IBufferWriter<byte> writer);
+    public abstract void PersistAsync(T value, IBufferWriter<byte> writer);
 
     /// <summary>
     /// Deserializes a value of type <typeparamref name="T"/> from the provided <paramref name="data"/>.
@@ -30,7 +29,7 @@ public abstract class PersistentComponentStateSerializer<T> : IPersistentCompone
     /// <summary>
     /// Explicit interface implementation for non-generic serialization.
     /// </summary>
-    Task IPersistentComponentStateSerializer.PersistAsync(Type type, object value, IBufferWriter<byte> writer)
+    void IPersistentComponentStateSerializer.PersistAsync(Type type, object value, IBufferWriter<byte> writer)
         => PersistAsync((T)value, writer);
 
     /// <summary>

src/Components/Components/src/PersistentStateValueProvider.cs

@@ -71,26 +71,27 @@ public void Subscribe(ComponentState subscriber, in CascadingParameterInfo param
         // Resolve serializer outside the lambda
         var customSerializer = ResolveSerializer(propertyType);
 
-        _subscriptions[subscriber] = state.RegisterOnPersisting(async () =>
+        _subscriptions[subscriber] = state.RegisterOnPersisting(() =>
             {
                 var storageKey = ComputeKey(subscriber, propertyName);
                 var propertyGetter = ResolvePropertyGetter(subscriber.Component.GetType(), propertyName);
                 var property = propertyGetter.GetValue(subscriber.Component);
                 if (property == null)
                 {
-                    return;
+                    return Task.CompletedTask;
                 }
 
                 if (customSerializer != null)
                 {
                     using var writer = new PooledArrayBufferWriter<byte>();
-                    await customSerializer.PersistAsync(propertyType, property, writer);
+                    customSerializer.PersistAsync(propertyType, property, writer);
                     state.PersistAsBytes(storageKey, writer.WrittenMemory.ToArray());
-                    return;
+                    return Task.CompletedTask;
                 }
 
                 // Fallback to JSON serialization
                 state.PersistAsJson(storageKey, property, propertyType);
+                return Task.CompletedTask;
             }, subscriber.Renderer.GetComponentRenderMode(subscriber.Component));
     }
 
@@ -331,13 +332,13 @@ 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, PersistentComponentStateSerializer<TValue> serializer)
+    internal void PersistAsync<TValue>(string key, TValue instance, PersistentComponentStateSerializer<TValue> serializer)
     {
         ArgumentNullException.ThrowIfNull(key);
         ArgumentNullException.ThrowIfNull(serializer);
 
         using var writer = new PooledArrayBufferWriter<byte>();
-        await serializer.PersistAsync(instance, writer);
+        serializer.PersistAsync(instance, writer);
         state.PersistAsBytes(key, writer.WrittenMemory.ToArray());
     }
 

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

@@ -18,7 +18,7 @@ Microsoft.AspNetCore.Components.PersistentStateAttribute.PersistentStateAttribut
 Microsoft.AspNetCore.Components.Infrastructure.PersistentStateProviderServiceCollectionExtensions
 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>.PersistAsync(T value, System.Buffers.IBufferWriter<byte>! writer) -> void
 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!

src/Components/Components/test/IPersistentComponentStateSerializerTests.cs

@@ -12,7 +12,7 @@ namespace Microsoft.AspNetCore.Components;
 public class IPersistentComponentStateSerializerTests
 {
     [Fact]
-    public async Task PersistAsync_CanUseCustomSerializer()
+    public void PersistAsync_CanUseCustomSerializer()
     {
         // Arrange
         var currentState = new Dictionary<string, byte[]>();
@@ -25,7 +25,7 @@ public async Task PersistAsync_CanUseCustomSerializer()
         state.PersistingState = true;
 
         // Act
-        await stateValueProvider.PersistAsync("test-key", testValue, customSerializer);
+        stateValueProvider.PersistAsync("test-key", testValue, customSerializer);
 
         // Assert
         state.PersistingState = false;
@@ -64,11 +64,10 @@ public void TryTake_CanUseCustomSerializer()
 
     private class TestStringSerializer : PersistentComponentStateSerializer<string>
     {
-        public override Task PersistAsync(string value, IBufferWriter<byte> writer)
+        public override void PersistAsync(string value, IBufferWriter<byte> writer)
         {
             var bytes = Encoding.UTF8.GetBytes(value);
             writer.Write(bytes);
-            return Task.CompletedTask;
         }
 
         public override string Restore(ReadOnlySequence<byte> data)

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

@@ -13,12 +13,11 @@ namespace TestContentPackage;
 /// </summary>
 public class CustomIntSerializer : PersistentComponentStateSerializer<int>
 {
-    public override Task PersistAsync(int value, IBufferWriter<byte> writer)
+    public override void PersistAsync(int value, IBufferWriter<byte> writer)
     {
         var customFormat = $"CUSTOM:{value}";
         var bytes = Encoding.UTF8.GetBytes(customFormat);
         writer.Write(bytes);
-        return Task.CompletedTask;
     }
 
     public override int Restore(ReadOnlySequence<byte> data)