Initial support for persisting component state

Author: javiercn

src/Components/Components/src/CascadingParameterState.cs

@@ -13,17 +13,16 @@
 namespace Microsoft.AspNetCore.Components;
 
 internal readonly struct CascadingParameterState
+    (in CascadingParameterInfo parameterInfo, ICascadingValueSupplier valueSupplier, object? key)
 {
     private static readonly ConcurrentDictionary<Type, CascadingParameterInfo[]> _cachedInfos = new();
 
-    public CascadingParameterInfo ParameterInfo { get; }
-    public ICascadingValueSupplier ValueSupplier { get; }
+    public CascadingParameterInfo ParameterInfo { get; } = parameterInfo;
+    public ICascadingValueSupplier ValueSupplier { get; } = valueSupplier;
+    public object? Key { get; } = key;
 
     public CascadingParameterState(in CascadingParameterInfo parameterInfo, ICascadingValueSupplier valueSupplier)
-    {
-        ParameterInfo = parameterInfo;
-        ValueSupplier = valueSupplier;
-    }
+        : this(parameterInfo, valueSupplier, key: null) { }
 
     public static IReadOnlyList<CascadingParameterState> FindCascadingParameters(ComponentState componentState, out bool hasSingleDeliveryParameters)
     {
@@ -55,7 +54,7 @@ public static IReadOnlyList<CascadingParameterState> FindCascadingParameters(Com
             {
                 // Although not all parameters might be matched, we know the maximum number
                 resultStates ??= new List<CascadingParameterState>(infos.Length - infoIndex);
-                resultStates.Add(new CascadingParameterState(info, supplier));
+                resultStates.Add(new CascadingParameterState(info, supplier, componentState));
 
                 if (info.Attribute.SingleDelivery)
                 {

src/Components/Components/src/ICascadingValueSupplier.cs

@@ -13,6 +13,8 @@ internal interface ICascadingValueSupplier
 
     object? GetCurrentValue(in CascadingParameterInfo parameterInfo);
 
+    object? GetCurrentValue(object? key, in CascadingParameterInfo parameterInfo) => GetCurrentValue(parameterInfo);
+
     void Subscribe(ComponentState subscriber, in CascadingParameterInfo parameterInfo);
 
     void Unsubscribe(ComponentState subscriber, in CascadingParameterInfo parameterInfo);

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

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Microsoft.AspNetCore.Components.RenderTree;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
 namespace Microsoft.AspNetCore.Components.Infrastructure;
@@ -15,17 +16,30 @@ public class ComponentStatePersistenceManager
     private readonly ILogger<ComponentStatePersistenceManager> _logger;
 
     private bool _stateIsPersisted;
+    private readonly PersistentServicesRegistry? _servicesRegistry;
     private readonly Dictionary<string, byte[]> _currentState = new(StringComparer.Ordinal);
 
     /// <summary>
     /// Initializes a new instance of <see cref="ComponentStatePersistenceManager"/>.
     /// </summary>
+    /// <param name="logger"></param>
     public ComponentStatePersistenceManager(ILogger<ComponentStatePersistenceManager> logger)
     {
         State = new PersistentComponentState(_currentState, _registeredCallbacks);
         _logger = logger;
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="ComponentStatePersistenceManager"/>.
+    /// </summary>
+    /// <param name="logger"></param>
+    /// <param name="serviceProvider"></param>
+    public ComponentStatePersistenceManager(ILogger<ComponentStatePersistenceManager> logger, IServiceProvider serviceProvider) : this(logger)
+    {
+        _servicesRegistry = serviceProvider.GetService<PersistentServicesRegistry>();
+        _servicesRegistry?.RegisterForPersistence(State);
+    }
+
     /// <summary>
     /// Gets the <see cref="ComponentStatePersistenceManager"/> associated with the <see cref="ComponentStatePersistenceManager"/>.
     /// </summary>
@@ -40,6 +54,7 @@ public async Task RestoreStateAsync(IPersistentComponentStateStore store)
     {
         var data = await store.GetPersistedStateAsync();
         State.InitializeExistingState(data);
+        _servicesRegistry?.Restore(State);
     }
 
     /// <summary>

src/Components/Components/src/ParameterView.cs

@@ -437,7 +437,7 @@ public bool MoveNext()
                 _currentIndex = nextIndex;
 
                 var state = _cascadingParameters[_currentIndex];
-                var currentValue = state.ValueSupplier.GetCurrentValue(state.ParameterInfo);
+                var currentValue = state.ValueSupplier.GetCurrentValue(state.Key, state.ParameterInfo);
                 _current = new ParameterValue(state.ParameterInfo.PropertyName, currentValue!, true);
                 return true;
             }

src/Components/Components/src/PersistentComponentState.cs

@@ -87,6 +87,24 @@ public PersistingComponentStateSubscription RegisterOnPersisting(Func<Task> call
         _currentState.Add(key, JsonSerializer.SerializeToUtf8Bytes(instance, JsonSerializerOptionsProvider.Options));
     }
 
+    [RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed.")]
+    internal void PersistAsJson(string key, object instance, [DynamicallyAccessedMembers(JsonSerialized)] Type type)
+    {
+        ArgumentNullException.ThrowIfNull(key);
+
+        if (!PersistingState)
+        {
+            throw new InvalidOperationException("Persisting state is only allowed during an OnPersisting callback.");
+        }
+
+        if (_currentState.ContainsKey(key))
+        {
+            throw new ArgumentException($"There is already a persisted object under the same key '{key}'");
+        }
+
+        _currentState.Add(key, JsonSerializer.SerializeToUtf8Bytes(instance, type, JsonSerializerOptionsProvider.Options));
+    }
+
     /// <summary>
     /// Tries to retrieve the persisted state as JSON with the given <paramref name="key"/> and deserializes it into an
     /// instance of type <typeparamref name="TValue"/>.
@@ -114,6 +132,24 @@ public PersistingComponentStateSubscription RegisterOnPersisting(Func<Task> call
         }
     }
 
+    [RequiresUnreferencedCode("JSON serialization and deserialization might require types that cannot be statically analyzed.")]
+    internal bool TryTakeFromJson(string key, [DynamicallyAccessedMembers(JsonSerialized)] Type type, [MaybeNullWhen(false)] out object? instance)
+    {
+        ArgumentNullException.ThrowIfNull(type);
+        ArgumentNullException.ThrowIfNull(key);
+        if (TryTake(key, out var data))
+        {
+            var reader = new Utf8JsonReader(data);
+            instance = JsonSerializer.Deserialize(ref reader, type, JsonSerializerOptionsProvider.Options);
+            return true;
+        }
+        else
+        {
+            instance = default;
+            return false;
+        }
+    }
+
     private bool TryTake(string key, out byte[]? value)
     {
         ArgumentNullException.ThrowIfNull(key);

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

@@ -0,0 +1,10 @@
+// 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 interface IPersistentComponentRegistration
+{
+    public string Assembly { get; }
+    public string FullTypeName { get; }
+}

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

@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics;
+
+namespace Microsoft.AspNetCore.Components;
+
+[DebuggerDisplay($"{{{nameof(GetDebuggerDisplay)}(),nq}}")]
+internal class PersistentComponentRegistration<TService> : IPersistentComponentRegistration
+{
+    public string Assembly => typeof(TService).Assembly.GetName().Name!;
+    public string FullTypeName => typeof(TService).FullName!;
+
+    private string GetDebuggerDisplay() => $"{Assembly}::{FullTypeName}";
+}

src/Components/Components/src/PersistentState/PersistentServiceTypeCache.cs

@@ -0,0 +1,82 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Concurrent;
+using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+
+namespace Microsoft.AspNetCore.Components;
+
+// A cache for registered persistent services. This is similar to the `RootComponentTypeCache`.
+internal sealed class PersistentServiceTypeCache
+{
+    private readonly ConcurrentDictionary<Key, Type?> _typeToKeyLookUp = new();
+
+    public Type? GetPersistentService(string assembly, string type)
+    {
+        var key = new Key(assembly, type);
+        if (_typeToKeyLookUp.TryGetValue(key, out var resolvedType))
+        {
+            return resolvedType;
+        }
+        else
+        {
+            return _typeToKeyLookUp.GetOrAdd(key, ResolveType, AppDomain.CurrentDomain.GetAssemblies());
+        }
+    }
+
+    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Types in this cache are added by calling `AddPersistentService` and are expected to be preserved.")]
+    private static Type? ResolveType(Key key, Assembly[] assemblies)
+    {
+        Assembly? assembly = null;
+        for (var i = 0; i < assemblies.Length; i++)
+        {
+            var current = assemblies[i];
+            if (current.GetName().Name == key.Assembly)
+            {
+                assembly = current;
+                break;
+            }
+        }
+
+        if (assembly == null)
+        {
+            // It might be that the assembly is not loaded yet, this can happen if the root component is defined in a
+            // different assembly than the app and there is no reference from the app assembly to any type in the class
+            // library that has been used yet.
+            // In this case, try and load the assembly and look up the type again.
+            // We only need to do this in the browser because its a different process, in the server the assembly will already
+            // be loaded.
+            if (OperatingSystem.IsBrowser())
+            {
+                try
+                {
+                    assembly = Assembly.Load(key.Assembly);
+                }
+                catch
+                {
+                    // It's fine to ignore the exception, since we'll return null below.
+                }
+            }
+        }
+
+        return assembly?.GetType(key.Type, throwOnError: false, ignoreCase: false);
+    }
+
+    private readonly struct Key : IEquatable<Key>
+    {
+        public Key(string assembly, string type) =>
+            (Assembly, Type) = (assembly, type);
+
+        public string Assembly { get; }
+
+        public string Type { get; }
+
+        public override bool Equals(object? obj) => obj is Key key && Equals(key);
+
+        public bool Equals(Key other) => string.Equals(Assembly, other.Assembly, StringComparison.Ordinal) &&
+            string.Equals(Type, other.Type, StringComparison.Ordinal);
+
+        public override int GetHashCode() => HashCode.Combine(Assembly, Type);
+    }
+}