[Blazor] PersistentComponentStateSerializer API review feedback

[javiercn]

Once I have it working, I would like to check how much setup I would need to create and register a general serializer that would work for any type or a subset of types.

My key concerns would be that:

1. It might not be possible to register a single generic serializer for any type, so you will have to register serializers for all types manually.
2. If it is possible to register a serializer for any generic type, it might not be possible to constrain this to only work for a subset of types. Imagine that I add a serializer that builds on MessagePack, but that this can only serialize types that are annotated with the [MessagePackObject] attribute, then I would not be able to say that it should fall back to JSON for types that are not annotated correctly. Preferebly it would be nice to have some way to add custom logic for whether a generic serializer could serialize a specific Type like in the Chain-of-responsibility pattern.

But since I haven't gotten the minimal sample to work yet, I have not been able to see what was needed for the above use cases.

Originally posted by @KristofferStrube in #62589

[KristofferStrube]

@javiercn can you spot whether I am missing anything obvious in my setup?

I have tried to follow the basic usage presented in #62589

My Program.cs is:

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();

builder.Services.AddSingleton<PersistentComponentStateSerializer<int>, IntSerializer>();

var app = builder.Build();

app.UseAntiforgery();

app.MapStaticAssets();
app.MapRazorComponents<App>()
    .AddInteractiveServerRenderMode();

app.Run();

IntSerializer.cs:

public class IntSerializer : PersistentComponentStateSerializer<int>
{
    public override void Persist(int value, IBufferWriter<byte> writer)
    {
        Console.WriteLine("Serialization Started!");
        writer.Write(JsonSerializer.SerializeToUtf8Bytes(value));
        Console.WriteLine("Serialization Done!");
    }

    public override int Restore(ReadOnlySequence<byte> data)
    {
        Console.WriteLine("Deserialization Started!");
        var value = JsonSerializer.Deserialize<int>(data.FirstSpan)!;
        Console.WriteLine("Deserialization Done!");
        return value;
    }
}

Counter.cs:

@page "/counter"
@rendermode InteractiveServer

<p role="status">Current count: @CurrentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    [PersistentState]
    public int CurrentCount { get; set; } = 0;

    protected override void OnInitialized()
    {
        Console.WriteLine("Counter page initialized!");
    }

    protected override void OnAfterRender(bool firstRender)
    {
        Console.WriteLine("Counter page rendered!");
    }

    private void IncrementCount()
    {
        CurrentCount++;
    }
}

I expected that the serializer would get its Persist and Restore methods invoked when I forcefully closed the connection from the browser with the command that Dan showed:

Blazor._internal.forceCloseConnection();

But it doesn't seem to.

I tried to take a look at the Startup file used in the E2E test project used in the PR for the feature, but I can't spot any other part that I would be missing. I noticed that the test project specifically configures the circuit state to be persisted if a flag is set, which I also attempted to add to my project, but that didn't make any difference.

// This disables the reconnection cache, which forces the server to persist the circuit state.
options.DisconnectedCircuitMaxRetained = 0;
options.DetailedErrors = true;

[javiercn]

@KristofferStrube You don't need to force a disconnection to trigger state persistence, it's enough that you prerender the page with the component that uses PersistentState.

I can't tell from the snippets that you provide that there's anything wrong. Have you tried putting a breakpoint and seeing if it gets hit?

Alternatively, can you share the project as a public github repository?

[javiercn]

It might not be possible to register a single generic serializer for any type, so you will have to register serializers for all types manually.
If it is possible to register a serializer for any generic type, it might not be possible to constrain this to only work for a subset of types. Imagine that I add a serializer that builds on MessagePack, but that this can only serialize types that are annotated with the [MessagePackObject] attribute, then I would not be able to say that it should fall back to JSON for types that are not annotated correctly. Preferebly it would be nice to have some way to add custom logic for whether a generic serializer could serialize a specific Type like in the Chain-of-responsibility pattern.

To answer this, you can register an open generic type definition in DI and that will apply to those types. If you want to do only a subset of types, I think you could potentially use a factory to check the type, see if it's annotated and return a serializer or return null otherwise (and the default serialization will apply then).

[KristofferStrube]

@javiercn I have put my project in this repo: https://github.com/KristofferStrube/CustomPersistentComponentStateSerializerIssue

I am having problems getting the debugger to work because it is a daily build of .NET, which is the reason I went for the "obtuse" print debugging.

[javiercn]

[javiercn]

I used the latest nightly 10.0.100-rc.1.25406.102