add support for specifying the render mode for the persisted service

Author: javiercn

src/Components/Components/src/Infrastructure/ComponentStatePersistenceManager.cs

@@ -134,6 +134,13 @@ private void InferRenderModes(Renderer renderer)
                 continue;
             }
 
+            if (registration.Callback.Target is PersistentServicesRegistry)
+            {
+                // The registration callback is associated with the services registry, which is a special case.
+                // We don't need to infer the render mode for this case.
+                continue;
+            }
+
             throw new InvalidOperationException(
                 $"The registered callback {registration.Callback.Method.Name} must be associated with a component or define" +
                 $" an explicit render mode type during registration.");

src/Components/Components/src/PersistentState/IPersistentComponentRegistration.cs

@@ -3,8 +3,26 @@
 
 namespace Microsoft.AspNetCore.Components;
 
-internal interface IPersistentComponentRegistration
+internal interface IPersistentComponentRegistration : IComparable<IPersistentComponentRegistration>, IEquatable<IPersistentComponentRegistration>
 {
     public string Assembly { get; }
     public string FullTypeName { get; }
+
+    public IComponentRenderMode? GetRenderModeOrDefault();
+
+    int IComparable<IPersistentComponentRegistration>.CompareTo(IPersistentComponentRegistration? other)
+    {
+        var assemblyComparison = string.Compare(Assembly, other?.Assembly, StringComparison.Ordinal);
+        if (assemblyComparison != 0)
+        {
+            return assemblyComparison;
+        }
+        return string.Compare(FullTypeName, other?.FullTypeName, StringComparison.Ordinal);
+    }
+
+    bool IEquatable<IPersistentComponentRegistration>.Equals(IPersistentComponentRegistration? other)
+    {
+        return string.Equals(Assembly, other?.Assembly, StringComparison.Ordinal) &&
+            string.Equals(FullTypeName, other?.FullTypeName, StringComparison.Ordinal);
+    }
 }

src/Components/Components/src/PersistentState/PersistentComponentRegistration.cs

@@ -6,10 +6,12 @@
 namespace Microsoft.AspNetCore.Components;
 
 [DebuggerDisplay($"{{{nameof(GetDebuggerDisplay)}(),nq}}")]
-internal class PersistentComponentRegistration<TService> : IPersistentComponentRegistration
+internal class PersistentComponentRegistration<TService>(IComponentRenderMode componentRenderMode) : IPersistentComponentRegistration
 {
     public string Assembly => typeof(TService).Assembly.GetName().Name!;
     public string FullTypeName => typeof(TService).FullName!;
 
+    public IComponentRenderMode? GetRenderModeOrDefault() => componentRenderMode;
+
     private string GetDebuggerDisplay() => $"{Assembly}::{FullTypeName}";
 }

src/Components/Components/src/PersistentState/PersistentServiceRenderMode.cs

@@ -0,0 +1,9 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Components;
+
+internal class PersistentServiceRenderMode(IComponentRenderMode componentRenderMode)
+{
+    public IComponentRenderMode ComponentRenderMode { get; } = componentRenderMode;
+}

src/Components/Components/src/PersistentState/PersistentServicesRegistry.cs

@@ -20,8 +20,8 @@ internal class PersistentServicesRegistry
 
     private readonly IServiceProvider _serviceProvider;
     private readonly PersistentServiceTypeCache _persistentServiceTypeCache;
-    private IEnumerable<IPersistentComponentRegistration> _registrations;
-    private PersistingComponentStateSubscription _subscription;
+    private IPersistentComponentRegistration[] _registrations;
+    private List<PersistingComponentStateSubscription> _subscriptions = [];
     private static readonly ConcurrentDictionary<Type, PropertiesAccessor> _cachedAccessorsByType = new();
 
     public PersistentServicesRegistry(
@@ -30,7 +30,7 @@ public PersistentServicesRegistry(
     {
         _serviceProvider = serviceProvider;
         _persistentServiceTypeCache = new PersistentServiceTypeCache();
-        _registrations = registrations;
+        _registrations = [.. registrations.Distinct().Order()];
     }
 
     [DebuggerDisplay($"{{{nameof(GetDebuggerDisplay)}(),nq}}")]
@@ -40,6 +40,8 @@ private class PersistentComponentRegistration : IPersistentComponentRegistration
 
         public string FullTypeName { get; set; } = "";
 
+        public IComponentRenderMode? GetRenderModeOrDefault() => null;
+
         private string GetDebuggerDisplay() => $"{Assembly}::{FullTypeName}";
     }
 
@@ -76,24 +78,6 @@ private static void RestoreInstanceState(object instance, Type type, PersistentC
         }
     }
 
-    [UnconditionalSuppressMessage("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", Justification = "<Pending>")]
-    private void PersistServicesState(PersistentComponentState state)
-    {
-        // Persist all the registrations
-        state.PersistAsJson(_registryKey, _registrations);
-        foreach (var registration in _registrations)
-        {
-            var type = ResolveType(registration.Assembly, registration.FullTypeName);
-            if (type == null)
-            {
-                continue;
-            }
-
-            var instance = _serviceProvider.GetRequiredService(type);
-            PersistInstanceState(instance, type, state);
-        }
-    }
-
     [RequiresUnreferencedCode("Calls Microsoft.AspNetCore.Components.PersistentComponentState.PersistAsJson(String, Object, Type)")]
     private static void PersistInstanceState(object instance, Type type, PersistentComponentState state)
     {
@@ -114,28 +98,67 @@ private static void PersistInstanceState(object instance, Type type, PersistentC
     [UnconditionalSuppressMessage("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", Justification = "<Pending>")]
     internal void Restore(PersistentComponentState state)
     {
-        if (_registrations?.Any() != true &&
-           state.TryTakeFromJson<IEnumerable<PersistentComponentRegistration>>(_registryKey, out var registry) &&
+        if (_registrations.Length == 0 &&
+           state.TryTakeFromJson<PersistentComponentRegistration[]>(_registryKey, out var registry) &&
            registry != null)
         {
-            _registrations = registry;
+            _registrations = registry ?? [];
         }
 
         RestoreRegistrationsIfAvailable(state);
     }
 
+    [UnconditionalSuppressMessage("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", Justification = "<Pending>")]
     internal void RegisterForPersistence(PersistentComponentState state)
     {
-        if (!_subscription.Equals(default(PersistingComponentStateSubscription)))
+        if (_subscriptions.Count != 0)
         {
             return;
         }
 
-        _subscription = state.RegisterOnPersisting(() =>
+        var comparer = EqualityComparer<IComponentRenderMode?>.Create((x, y) =>
         {
-            PersistServicesState(state);
-            return Task.CompletedTask;
+            var xType = x?.GetType();
+            var yType = y?.GetType();
+            return xType == yType;
         });
+
+        var renderModes = new HashSet<IComponentRenderMode?>(comparer);
+
+        var subscriptions = new List<PersistingComponentStateSubscription>(_registrations.Length + 1);
+        for (var i = 1; i < _registrations.Length; i++)
+        {
+            var registration = _registrations[i];
+            var type = ResolveType(registration.Assembly, registration.FullTypeName);
+            if (type == null)
+            {
+                continue;
+            }
+
+            var renderMode = registration.GetRenderModeOrDefault();
+            if (renderMode != null)
+            {
+                renderModes.Add(renderMode);
+            }
+
+            var instance = _serviceProvider.GetRequiredService(type);
+            subscriptions.Add(state.RegisterOnPersisting(() =>
+            {
+                PersistInstanceState(instance, type, state);
+                return Task.CompletedTask;
+            }, renderMode));
+        }
+
+        foreach (var renderMode in renderModes)
+        {
+            subscriptions.Add(state.RegisterOnPersisting(() =>
+            {
+                state.PersistAsJson(_registryKey, _registrations);
+                return Task.CompletedTask;
+            }, renderMode));
+        }
+
+        _subscriptions = subscriptions;
     }
 
     private sealed class PropertiesAccessor

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

@@ -3,5 +3,5 @@ Microsoft.AspNetCore.Components.Infrastructure.ComponentStatePersistenceManager.
 Microsoft.AspNetCore.Components.SupplyParameterFromPersistentComponentStateAttribute
 Microsoft.AspNetCore.Components.SupplyParameterFromPersistentComponentStateAttribute.SupplyParameterFromPersistentComponentStateAttribute() -> void
 Microsoft.AspNetCore.Components.SupplyParameterFromPersistentComponentStateProviderServiceCollectionExtensions
-static Microsoft.AspNetCore.Components.SupplyParameterFromPersistentComponentStateProviderServiceCollectionExtensions.AddPersistentService<TService>(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!
+static Microsoft.AspNetCore.Components.SupplyParameterFromPersistentComponentStateProviderServiceCollectionExtensions.AddPersistentService<TService>(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services, Microsoft.AspNetCore.Components.IComponentRenderMode! componentRenderMode) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!
 static Microsoft.AspNetCore.Components.SupplyParameterFromPersistentComponentStateProviderServiceCollectionExtensions.AddSupplyValueFromPersistentComponentStateProvider(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!

src/Components/Components/src/SupplyParameterFromPersistentComponentStateProviderServiceCollectionExtensions.cs

@@ -32,8 +32,11 @@ public static IServiceCollection AddSupplyValueFromPersistentComponentStateProvi
     /// </remarks>
     /// <typeparam name="TService">The service type to register for persistence.</typeparam>
     /// <param name="services">The <see cref="IServiceCollection"/>.</param>
+    /// <param name="componentRenderMode">The <see cref="IComponentRenderMode"/> to register the service for.</param>
     /// <returns>The <see cref="IServiceCollection"/>.</returns>
-    public static IServiceCollection AddPersistentService<[DynamicallyAccessedMembers(JsonSerialized)] TService>(this IServiceCollection services)
+    public static IServiceCollection AddPersistentService<[DynamicallyAccessedMembers(JsonSerialized)] TService>(
+        this IServiceCollection services,
+        IComponentRenderMode componentRenderMode)
     {
         // This method does something very similar to what we do when we register root components, except in this case we are registering services.
         // We collect a list of all the registrations on during static rendering mode and push those registrations to interactive mode.
@@ -47,7 +50,8 @@ public static IServiceCollection AddSupplyValueFromPersistentComponentStateProvi
         //       We can choose to fail when the service is not registered on DI.
         // We loop through the properties in the type and try to restore the properties that have SupplyParameterFromPersistentComponentState on them.
         services.TryAddScoped<PersistentServicesRegistry>();
-        services.TryAddEnumerable(ServiceDescriptor.Singleton<IPersistentComponentRegistration, PersistentComponentRegistration<TService>>());
+        //services.TryAddEnumerable(ServiceDescriptor.Singleton(new PersistentServiceRenderMode(componentRenderMode)));
+        services.TryAddEnumerable(ServiceDescriptor.Singleton<IPersistentComponentRegistration>(new PersistentComponentRegistration<TService>(componentRenderMode)));
 
         return services;
     }

src/Components/Endpoints/src/DependencyInjection/RazorComponentsServiceCollectionExtensions.cs

@@ -79,7 +79,7 @@ public static IRazorComponentsBuilder AddRazorComponents(this IServiceCollection
         services.AddSupplyValueFromFormProvider();
         services.TryAddScoped<AntiforgeryStateProvider, EndpointAntiforgeryStateProvider>();
         services.TryAddScoped(sp => (EndpointAntiforgeryStateProvider)sp.GetRequiredService<AntiforgeryStateProvider>());
-        services.AddPersistentService<AntiforgeryStateProvider>();
+        services.AddPersistentService<AntiforgeryStateProvider>(RenderMode.InteractiveAuto);
         services.TryAddScoped<HttpContextFormDataProvider>();
         services.TryAddScoped<IFormValueMapper, HttpContextFormValueMapper>();
 

src/Components/Samples/BlazorServerApp/Startup.cs

@@ -4,6 +4,7 @@
 using BlazorServerApp.Data;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Authorization;
+using Microsoft.AspNetCore.Components.Web;
 
 namespace BlazorServerApp;
 
@@ -23,7 +24,7 @@ public void ConfigureServices(IServiceCollection services)
         services.AddRazorPages();
         services.AddServerSideBlazor();
         services.AddScoped<SamplePersistentService>();
-        services.AddPersistentService<SamplePersistentService>();
+        services.AddPersistentService<SamplePersistentService>(RenderMode.InteractiveServer);
         services.AddSingleton<WeatherForecastService>();
     }