tmp

Author: javiercn

src/Components/Components/src/Lifetime/ComponentStatePersistenceManager.cs

@@ -5,6 +5,8 @@
 using System.Buffers;
 using System.Collections.Generic;
 using System.IO.Pipelines;
+using System.Text.Json;
+using System.Text.Json.Serialization;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Components.Lifetime;
 using Microsoft.AspNetCore.Components.RenderTree;

src/Components/Components/src/Lifetime/PersistentComponentState.cs

@@ -117,6 +117,7 @@ public void Persist(string key, Action<IBufferWriter<byte>> valueWriter)
             var pipe = new Pipe();
             _currentState.Add(key, pipe);
             valueWriter(pipe.Writer);
+            pipe.Writer.Complete();
         }
 
         /// <summary>
@@ -145,6 +146,7 @@ public void Persist(string key, Action<IBufferWriter<byte>> valueWriter)
             var pipe = new Pipe();
             _currentState.Add(key, pipe);
             JsonSerializer.Serialize(new Utf8JsonWriter(pipe.Writer), instance, JsonSerializerOptionsProvider.Options);
+            pipe.Writer.Complete();
         }
 
         /// <summary>

src/Components/Components/src/Microsoft.AspNetCore.Components.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>$(DefaultNetCoreTargetFramework)</TargetFramework>
@@ -18,6 +18,7 @@
   <ItemGroup>
     <Reference Include="Microsoft.Extensions.Logging.Abstractions" />
     <Reference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
+    <Reference Include="System.IO.Pipelines" />
   </ItemGroup>
 
   <!--

src/Shared/Components/PrerenderComponentApplicationStore.cs

@@ -22,10 +22,21 @@ public PrerenderComponentApplicationStore(string existingState)
             if (existingState is null)
             {
                 throw new ArgumentNullException(nameof(existingState));
-            }            
+            }
 
-            ExistingState = JsonSerializer.Deserialize<Dictionary<string, ReadOnlySequence<byte>>>(Convert.FromBase64String(existingState)) ??
-                throw new ArgumentException(nameof(existingState));
+            var state = JsonSerializer.Deserialize<Dictionary<string, byte[]>>(Convert.FromBase64String(existingState));
+            if (state == null)
+            {
+                throw new ArgumentException("Could not deserialize state correctly", nameof(existingState));
+            }
+
+            var stateDictionary = new Dictionary<string, ReadOnlySequence<byte>>();
+            foreach (var (key, value) in state)
+            {
+                stateDictionary.Add(key, new ReadOnlySequence<byte>(value));
+            }
+
+            ExistingState = stateDictionary;
         }
 
 #nullable enable
@@ -41,7 +52,37 @@ public Task<IDictionary<string, ReadOnlySequence<byte>>> GetPersistedStateAsync(
 
         protected virtual byte[] SerializeState(IReadOnlyDictionary<string, ReadOnlySequence<byte>> state)
         {
-            return JsonSerializer.SerializeToUtf8Bytes(state);
+            // System.Text.Json doesn't support serializing ReadonlySequence<byte> so we need to buffer
+            // the data with a memory pool here. We will change our serialization strategy in the future here
+            // so that we can avoid this step.
+            var pool = MemoryPool<byte>.Shared;
+            var memory = new List<IMemoryOwner<byte>>();
+            var serialization = new Dictionary<string, Memory<byte>>();
+            try
+            {
+                foreach (var (key, value) in state)
+                {
+                    IMemoryOwner<byte> buffer = null;
+                    if (value.Length < pool.MaxBufferSize)
+                    {
+                        buffer = pool.Rent((int)value.Length);
+                        memory.Add(buffer);
+                        value.CopyTo(buffer.Memory.Span.Slice(0, (int)value.Length));
+                    }
+
+                    serialization.Add(key, buffer != null ? buffer.Memory.Slice(0, (int)value.Length) : value.ToArray());
+                }
+
+                return JsonSerializer.SerializeToUtf8Bytes(serialization, JsonSerializerOptionsProvider.Options);
+            }
+            finally
+            {
+                serialization.Clear();
+                foreach (var item in memory)
+                {
+                    item.Dispose();
+                }
+            }
         }
 
         public Task PersistStateAsync(IReadOnlyDictionary<string, ReadOnlySequence<byte>> state)