Unify RootComponentTypeCache and PersistentServiceTypeCache

javiercn · javiercn · commit 2ef98cd9a191 · 2025-03-13T17:19:41.000+01:00
diff --git a/src/Components/Components/src/Microsoft.AspNetCore.Components.csproj b/src/Components/Components/src/Microsoft.AspNetCore.Components.csproj
@@ -17,6 +17,7 @@
     <Compile Include="$(ComponentsSharedSourceRoot)src\ArrayBuilder.cs" LinkBase="RenderTree" />
     <Compile Include="$(ComponentsSharedSourceRoot)src\JsonSerializerOptionsProvider.cs" />
     <Compile Include="$(ComponentsSharedSourceRoot)src\HotReloadManager.cs" LinkBase="HotReload" />
+    <Compile Include="$(ComponentsSharedSourceRoot)src\RootTypeCache.cs" LinkBase="Shared" />
     <Compile Include="$(SharedSourceRoot)LinkerFlags.cs" LinkBase="Shared" />
     <Compile Include="$(SharedSourceRoot)QueryStringEnumerable.cs" LinkBase="Shared" />
     <Compile Include="$(SharedSourceRoot)Debugger\DictionaryItemDebugView.cs" LinkBase="Shared" />
diff --git a/src/Components/Components/src/PersistentState/IPersistentServiceRegistration.cs b/src/Components/Components/src/PersistentState/IPersistentServiceRegistration.cs
@@ -4,7 +4,7 @@
 namespace Microsoft.AspNetCore.Components;
 
 // Represents a component that is registered for state persistence.
-internal interface IPersistentComponentRegistration
+internal interface IPersistentServiceRegistration
 {
     public string Assembly { get; }
     public string FullTypeName { get; }
diff --git a/src/Components/Components/src/PersistentState/PersistentServiceRegistration.cs b/src/Components/Components/src/PersistentState/PersistentServiceRegistration.cs
@@ -6,7 +6,7 @@
 namespace Microsoft.AspNetCore.Components;
 
 [DebuggerDisplay($"{{{nameof(GetDebuggerDisplay)}(),nq}}")]
-internal sealed class PersistentComponentRegistration<TService>(IComponentRenderMode componentRenderMode) : IPersistentComponentRegistration
+internal sealed class PersistentServiceRegistration<TService>(IComponentRenderMode componentRenderMode) : IPersistentServiceRegistration
 {
     public string Assembly => typeof(TService).Assembly.GetName().Name!;
     public string FullTypeName => typeof(TService).FullName!;
diff --git a/src/Components/Components/src/PersistentState/PersistentServiceTypeCache.cs b/src/Components/Components/src/PersistentState/PersistentServiceTypeCache.cs
diff --git a/src/Components/Components/src/PersistentState/PersistentServicesRegistry.cs b/src/Components/Components/src/PersistentState/PersistentServicesRegistry.cs
@@ -17,24 +17,23 @@ namespace Microsoft.AspNetCore.Components.Infrastructure;
 internal sealed class PersistentServicesRegistry
 {
     private static readonly string _registryKey = typeof(PersistentServicesRegistry).FullName!;
+    private static readonly RootTypeCache _persistentServiceTypeCache = new RootTypeCache();
 
     private readonly IServiceProvider _serviceProvider;
-    private readonly PersistentServiceTypeCache _persistentServiceTypeCache;
-    private IPersistentComponentRegistration[] _registrations;
+    private IPersistentServiceRegistration[] _registrations;
     private List<PersistingComponentStateSubscription> _subscriptions = [];
     private static readonly ConcurrentDictionary<Type, PropertiesAccessor> _cachedAccessorsByType = new();
 
     public PersistentServicesRegistry(IServiceProvider serviceProvider)
     {
-        var registrations = serviceProvider.GetRequiredService<IEnumerable<IPersistentComponentRegistration>>();
+        var registrations = serviceProvider.GetRequiredService<IEnumerable<IPersistentServiceRegistration>>();
         _serviceProvider = serviceProvider;
-        _persistentServiceTypeCache = new PersistentServiceTypeCache();
         _registrations = ResolveRegistrations(registrations);
     }
 
     internal IComponentRenderMode? RenderMode { get; set; }
 
-    internal IReadOnlyList<IPersistentComponentRegistration> Registrations => _registrations;
+    internal IReadOnlyList<IPersistentServiceRegistration> Registrations => _registrations;
 
     [UnconditionalSuppressMessage(
         "Trimming",
@@ -97,10 +96,10 @@ 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 = "Types registered for persistence are preserved in the API call to register them and typically live in assemblies that aren't trimmed.")]
-    [DynamicDependency(LinkerFlags.JsonSerialized, typeof(PersistentComponentRegistration))]
+    [DynamicDependency(LinkerFlags.JsonSerialized, typeof(PersistentServiceRegistration))]
     internal void Restore(PersistentComponentState state)
     {
-        if (state.TryTakeFromJson<PersistentComponentRegistration[]>(_registryKey, out var registry) && registry != null)
+        if (state.TryTakeFromJson<PersistentServiceRegistration[]>(_registryKey, out var registry) && registry != null)
         {
             _registrations = ResolveRegistrations(_registrations.Concat(registry));
         }
@@ -141,9 +140,10 @@ private static void RestoreInstanceState(object instance, Type type, PersistentC
         }
     }
 
-    private static IPersistentComponentRegistration[] ResolveRegistrations(IEnumerable<IPersistentComponentRegistration> registrations) => [.. registrations.DistinctBy(r => (r.Assembly, r.FullTypeName)).OrderBy(r => r.Assembly).ThenBy(r => r.FullTypeName)];
+    private static IPersistentServiceRegistration[] ResolveRegistrations(IEnumerable<IPersistentServiceRegistration> registrations) => [.. registrations.DistinctBy(r => (r.Assembly, r.FullTypeName)).OrderBy(r => r.Assembly).ThenBy(r => r.FullTypeName)];
 
-    private Type? ResolveType(string assembly, string fullTypeName) => _persistentServiceTypeCache.GetPersistentService(assembly, fullTypeName);
+    private static Type? ResolveType(string assembly, string fullTypeName) =>
+        _persistentServiceTypeCache.GetRootType(assembly, fullTypeName);
 
     private sealed class PropertiesAccessor
     {
@@ -217,7 +217,7 @@ internal static IEnumerable<PropertyInfo> GetCandidateBindableProperties(
     }
 
     [DebuggerDisplay($"{{{nameof(GetDebuggerDisplay)}(),nq}}")]
-    private class PersistentComponentRegistration : IPersistentComponentRegistration
+    private class PersistentServiceRegistration : IPersistentServiceRegistration
     {
         public string Assembly { get; set; } = "";
 
diff --git a/src/Components/Components/src/RenderTree/Renderer.cs b/src/Components/Components/src/RenderTree/Renderer.cs
@@ -316,7 +316,7 @@ protected internal void RemoveRootComponent(int componentId)
     /// </summary>
     /// <param name="componentId">The root component ID.</param>
     /// <returns>The type of the component.</returns>
-    internal Type GetRootComponentType(int componentId)
+    internal Type GetRootTypeType(int componentId)
         => GetRequiredRootComponentState(componentId).Component.GetType();
 
     /// <summary>
@@ -1130,9 +1130,9 @@ private void HandleExceptionViaErrorBoundary(Exception error, ComponentState? er
     /// <param name="disposing"><see langword="true"/> if this method is being invoked by <see cref="IDisposable.Dispose"/>, otherwise <see langword="false"/>.</param>
     protected virtual void Dispose(bool disposing)
     {
-        // Unlike other Renderer APIs, we need Dispose to be thread-safe 
-        // (and not require being called only from the sync context) 
-        // because other classes many need to dispose a Renderer during their own Dispose (rather than DisposeAsync) 
+        // Unlike other Renderer APIs, we need Dispose to be thread-safe
+        // (and not require being called only from the sync context)
+        // because other classes many need to dispose a Renderer during their own Dispose (rather than DisposeAsync)
         // and we don't want to force that other code to deal with calling InvokeAsync from a synchronous method.
         lock (_lockObject)
         {
diff --git a/src/Components/Components/src/SupplyParameterFromPersistentComponentStateProviderServiceCollectionExtensions.cs b/src/Components/Components/src/SupplyParameterFromPersistentComponentStateProviderServiceCollectionExtensions.cs
@@ -46,7 +46,7 @@ public static IServiceCollection AddSupplyValueFromPersistentComponentStateProvi
         // We look for the type inside the assembly.
         // We resolve the service from the DI container.
         // We loop through the properties in the type and try to restore the properties that have SupplyParameterFromPersistentComponentState on them.
-        services.TryAddEnumerable(ServiceDescriptor.Singleton<IPersistentComponentRegistration>(new PersistentComponentRegistration<TService>(componentRenderMode)));
+        services.TryAddEnumerable(ServiceDescriptor.Singleton<IPersistentServiceRegistration>(new PersistentServiceRegistration<TService>(componentRenderMode)));
 
         return services;
     }
diff --git a/src/Components/Components/test/PersistentState/ComponentStatePersistenceManagerTest.cs b/src/Components/Components/test/PersistentState/ComponentStatePersistenceManagerTest.cs
@@ -422,7 +422,7 @@ private class TestRenderMode : IComponentRenderMode
     {
     }
 
-    private class PersistentService : IPersistentComponentRegistration
+    private class PersistentService : IPersistentServiceRegistration
     {
         public string Assembly { get; set; }
 
diff --git a/src/Components/Components/test/PersistentState/PersistentServicesRegistryTest.cs b/src/Components/Components/test/PersistentState/PersistentServicesRegistryTest.cs
@@ -230,7 +230,7 @@ public async Task PersistStateAsync_DoesNotThrow_WhenTypeCantBeFoundForPersisted
         // Arrange
         var componentRenderMode = new TestRenderMode();
         var serviceProviderOne = new ServiceCollection()
-            .AddSingleton<IPersistentComponentRegistration>(new TestPersistentRegistration { Assembly = "FakeAssembly", FullTypeName = "FakeType" })
+            .AddSingleton<IPersistentServiceRegistration>(new TestPersistentRegistration { Assembly = "FakeAssembly", FullTypeName = "FakeType" })
             .BuildServiceProvider();
 
         var serviceProviderTwo = new ServiceCollection()
@@ -260,9 +260,9 @@ public void ResolveRegistrations_RemovesDuplicateRegistrations()
     {
         // Arrange
         var serviceProvider = new ServiceCollection()
-            .AddSingleton<IPersistentComponentRegistration>(new TestPersistentRegistration { Assembly = "Assembly1", FullTypeName = "Type1" })
-            .AddSingleton<IPersistentComponentRegistration>(new TestPersistentRegistration { Assembly = "Assembly1", FullTypeName = "Type1" }) // Duplicate
-            .AddSingleton<IPersistentComponentRegistration>(new TestPersistentRegistration { Assembly = "Assembly2", FullTypeName = "Type2" })
+            .AddSingleton<IPersistentServiceRegistration>(new TestPersistentRegistration { Assembly = "Assembly1", FullTypeName = "Type1" })
+            .AddSingleton<IPersistentServiceRegistration>(new TestPersistentRegistration { Assembly = "Assembly1", FullTypeName = "Type1" }) // Duplicate
+            .AddSingleton<IPersistentServiceRegistration>(new TestPersistentRegistration { Assembly = "Assembly2", FullTypeName = "Type2" })
             .BuildServiceProvider();
 
         var registry = new PersistentServicesRegistry(serviceProvider);
@@ -490,7 +490,7 @@ private class DerivedService : BaseServiceWithProperty
     {
     }
 
-    private class TestPersistentRegistration : IPersistentComponentRegistration
+    private class TestPersistentRegistration : IPersistentServiceRegistration
     {
         public string Assembly { get; set; }
         public string FullTypeName { get; set; }
diff --git a/src/Components/Server/src/Circuits/ServerComponentDeserializer.cs b/src/Components/Server/src/Circuits/ServerComponentDeserializer.cs
@@ -59,7 +59,7 @@ internal sealed partial class ServerComponentDeserializer : IServerComponentDese
 {
     private readonly IDataProtector _dataProtector;
     private readonly ILogger<ServerComponentDeserializer> _logger;
-    private readonly RootComponentTypeCache _rootComponentTypeCache;
+    private readonly RootTypeCache _RootTypeCache;
     private readonly ComponentParameterDeserializer _parametersDeserializer;
 
     // The following fields are only used in TryDeserializeSingleComponentDescriptor.
@@ -72,7 +72,7 @@ internal sealed partial class ServerComponentDeserializer : IServerComponentDese
     public ServerComponentDeserializer(
         IDataProtectionProvider dataProtectionProvider,
         ILogger<ServerComponentDeserializer> logger,
-        RootComponentTypeCache rootComponentTypeCache,
+        RootTypeCache RootTypeCache,
         ComponentParameterDeserializer parametersDeserializer)
     {
         // When we protect the data we use a time-limited data protector with the
@@ -87,7 +87,7 @@ public ServerComponentDeserializer(
             .ToTimeLimitedDataProtector();
 
         _logger = logger;
-        _rootComponentTypeCache = rootComponentTypeCache;
+        _RootTypeCache = RootTypeCache;
         _parametersDeserializer = parametersDeserializer;
     }
 
@@ -206,8 +206,8 @@ public bool TryDeserializeWebRootComponentDescriptor(ComponentMarker record, [No
     private bool TryDeserializeComponentTypeAndParameters(ServerComponent serverComponent, [NotNullWhen(true)] out Type? componentType, out ParameterView parameters)
     {
         parameters = default;
-        componentType = _rootComponentTypeCache
-            .GetRootComponent(serverComponent.AssemblyName, serverComponent.TypeName);
+        componentType = _RootTypeCache
+            .GetRootType(serverComponent.AssemblyName, serverComponent.TypeName);
 
         if (componentType == null)
         {
diff --git a/src/Components/Server/src/DependencyInjection/ComponentServiceCollectionExtensions.cs b/src/Components/Server/src/DependencyInjection/ComponentServiceCollectionExtensions.cs
@@ -62,7 +62,7 @@ public static IServerSideBlazorBuilder AddServerSideBlazor(this IServiceCollecti
         // Components entrypoints, this lot is the same and repeated registrations are a no-op.
         services.TryAddSingleton<ICircuitFactory, CircuitFactory>();
         services.TryAddSingleton<ICircuitHandleRegistry, CircuitHandleRegistry>();
-        services.TryAddSingleton<RootComponentTypeCache>();
+        services.TryAddSingleton<RootTypeCache>();
         services.TryAddSingleton<ComponentParameterDeserializer>();
         services.TryAddSingleton<ComponentParametersTypeCache>();
         services.TryAddSingleton<CircuitIdFactory>();
diff --git a/src/Components/Server/src/Microsoft.AspNetCore.Components.Server.csproj b/src/Components/Server/src/Microsoft.AspNetCore.Components.Server.csproj
@@ -48,7 +48,7 @@
     <Compile Include="$(ComponentsSharedSourceRoot)src\RootComponentOperation.cs" />
     <Compile Include="$(ComponentsSharedSourceRoot)src\RootComponentOperationBatch.cs" />
     <Compile Include="$(ComponentsSharedSourceRoot)src\RootComponentOperationType.cs" />
-    <Compile Include="$(ComponentsSharedSourceRoot)src\RootComponentTypeCache.cs" />
+    <Compile Include="$(ComponentsSharedSourceRoot)src\RootTypeCache.cs" />
     <Compile Include="$(ComponentsSharedSourceRoot)src\DefaultAntiforgeryStateProvider.cs" LinkBase="Forms" />
     <Compile Include="$(ComponentsSharedSourceRoot)src\WebRendererId.cs" />
 
diff --git a/src/Components/Server/test/Circuits/CircuitHostTest.cs b/src/Components/Server/test/Circuits/CircuitHostTest.cs
@@ -636,7 +636,7 @@ private ProtectedPrerenderComponentApplicationStore CreateStore()
 
     private ServerComponentDeserializer CreateDeserializer()
     {
-        return new ServerComponentDeserializer(_ephemeralDataProtectionProvider, NullLogger<ServerComponentDeserializer>.Instance, new RootComponentTypeCache(), new ComponentParameterDeserializer(NullLogger<ComponentParameterDeserializer>.Instance, new ComponentParametersTypeCache()));
+        return new ServerComponentDeserializer(_ephemeralDataProtectionProvider, NullLogger<ServerComponentDeserializer>.Instance, new RootTypeCache(), new ComponentParameterDeserializer(NullLogger<ComponentParameterDeserializer>.Instance, new ComponentParametersTypeCache()));
     }
 
     private static TestRemoteRenderer GetRemoteRenderer()
diff --git a/src/Components/Server/test/Circuits/RemoteRendererTest.cs b/src/Components/Server/test/Circuits/RemoteRendererTest.cs
@@ -646,7 +646,7 @@ private TestRemoteRenderer GetRemoteRenderer(IServiceProvider serviceProvider, C
         var serverComponentDeserializer = new ServerComponentDeserializer(
             _ephemeralDataProtectionProvider,
             NullLogger<ServerComponentDeserializer>.Instance,
-            new RootComponentTypeCache(),
+            new RootTypeCache(),
             new ComponentParameterDeserializer(
                 NullLogger<ComponentParameterDeserializer>.Instance,
                 new ComponentParametersTypeCache()));
diff --git a/src/Components/Server/test/Circuits/ServerComponentDeserializerTest.cs b/src/Components/Server/test/Circuits/ServerComponentDeserializerTest.cs
@@ -436,7 +436,7 @@ private ServerComponentDeserializer CreateServerComponentDeserializer()
         return new ServerComponentDeserializer(
             _ephemeralDataProtectionProvider,
             NullLogger<ServerComponentDeserializer>.Instance,
-            new RootComponentTypeCache(),
+            new RootTypeCache(),
             new ComponentParameterDeserializer(NullLogger<ComponentParameterDeserializer>.Instance, new ComponentParametersTypeCache()));
     }
 
diff --git a/src/Components/Shared/src/RootTypeCache.cs b/src/Components/Shared/src/RootTypeCache.cs
@@ -5,14 +5,18 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 
+#if COMPONENTS
+namespace Microsoft.AspNetCore.Components.Infrastructure;
+#else
 namespace Microsoft.AspNetCore.Components;
+#endif
 
 // A cache for root component types
-internal sealed class RootComponentTypeCache
+internal sealed class RootTypeCache
 {
     private readonly ConcurrentDictionary<Key, Type?> _typeToKeyLookUp = new();
 
-    public Type? GetRootComponent(string assembly, string type)
+    public Type? GetRootType(string assembly, string type)
     {
         var key = new Key(assembly, type);
         if (_typeToKeyLookUp.TryGetValue(key, out var resolvedType))
diff --git a/src/Components/Web/src/JSComponents/JSComponentInterop.cs b/src/Components/Web/src/JSComponents/JSComponentInterop.cs
@@ -87,7 +87,7 @@ protected internal void SetRootComponentParameters(int componentId, int paramete
             throw new ArgumentOutOfRangeException($"{nameof(parameterCount)} must be between 0 and {MaxParameters}.");
         }
 
-        var componentType = Renderer.GetRootComponentType(componentId);
+        var componentType = Renderer.GetRootTypeType(componentId);
         var parameterViewBuilder = new ParameterViewBuilder(parameterCount);
 
         var parametersJsonEnumerator = parametersJson.EnumerateObject();
diff --git a/src/Components/WebAssembly/WebAssembly/src/Hosting/WebAssemblyHostBuilder.cs b/src/Components/WebAssembly/WebAssembly/src/Hosting/WebAssemblyHostBuilder.cs
diff --git a/src/Components/WebAssembly/WebAssembly/src/Microsoft.AspNetCore.Components.WebAssembly.csproj b/src/Components/WebAssembly/WebAssembly/src/Microsoft.AspNetCore.Components.WebAssembly.csproj
diff --git a/src/Components/WebAssembly/WebAssembly/src/Services/DefaultWebAssemblyJSRuntime.cs b/src/Components/WebAssembly/WebAssembly/src/Services/DefaultWebAssemblyJSRuntime.cs

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`	`namespace Microsoft.AspNetCore.Components;`
`5`	`5`
`6`	`6`	`// Represents a component that is registered for state persistence.`
`7`		`-internal interface IPersistentComponentRegistration`
	`7`	`+internal interface IPersistentServiceRegistration`
`8`	`8`	`{`
`9`	`9`	`public string Assembly { get; }`
`10`	`10`	`public string FullTypeName { get; }`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`	`namespace Microsoft.AspNetCore.Components;`
`7`	`7`
`8`	`8`	`[DebuggerDisplay($"{{{nameof(GetDebuggerDisplay)}(),nq}}")]`
`9`		`-internal sealed class PersistentComponentRegistration<TService>(IComponentRenderMode componentRenderMode) : IPersistentComponentRegistration`
	`9`	`+internal sealed class PersistentServiceRegistration<TService>(IComponentRenderMode componentRenderMode) : IPersistentServiceRegistration`
`10`	`10`	`{`
`11`	`11`	`public string Assembly => typeof(TService).Assembly.GetName().Name!;`
`12`	`12`	`public string FullTypeName => typeof(TService).FullName!;`
Original file line number	Diff line number	Diff line change
`@@ -17,24 +17,23 @@ namespace Microsoft.AspNetCore.Components.Infrastructure;`
`17`	`17`	`internal sealed class PersistentServicesRegistry`
`18`	`18`	`{`
`19`	`19`	`private static readonly string _registryKey = typeof(PersistentServicesRegistry).FullName!;`
	`20`	`+ private static readonly RootTypeCache _persistentServiceTypeCache = new RootTypeCache();`
`20`	`21`
`21`	`22`	`private readonly IServiceProvider _serviceProvider;`
`22`		`- private readonly PersistentServiceTypeCache _persistentServiceTypeCache;`
`23`		`- private IPersistentComponentRegistration[] _registrations;`
	`23`	`+ private IPersistentServiceRegistration[] _registrations;`
`24`	`24`	`private List<PersistingComponentStateSubscription> _subscriptions = [];`
`25`	`25`	`private static readonly ConcurrentDictionary<Type, PropertiesAccessor> _cachedAccessorsByType = new();`
`26`	`26`
`27`	`27`	`public PersistentServicesRegistry(IServiceProvider serviceProvider)`
`28`	`28`	`{`
`29`		`- var registrations = serviceProvider.GetRequiredService<IEnumerable<IPersistentComponentRegistration>>();`
	`29`	`+ var registrations = serviceProvider.GetRequiredService<IEnumerable<IPersistentServiceRegistration>>();`
`30`	`30`	`_serviceProvider = serviceProvider;`
`31`		`- _persistentServiceTypeCache = new PersistentServiceTypeCache();`
`32`	`31`	`_registrations = ResolveRegistrations(registrations);`
`33`	`32`	`}`
`34`	`33`
`35`	`34`	`internal IComponentRenderMode? RenderMode { get; set; }`
`36`	`35`
`37`		`- internal IReadOnlyList<IPersistentComponentRegistration> Registrations => _registrations;`
	`36`	`+ internal IReadOnlyList<IPersistentServiceRegistration> Registrations => _registrations;`
`38`	`37`
`39`	`38`	`[UnconditionalSuppressMessage(`
`40`	`39`	`"Trimming",`
`@@ -97,10 +96,10 @@ private static void PersistInstanceState(object instance, Type type, PersistentC`
`97`	`96`	`[UnconditionalSuppressMessage("Trimming",`
`98`	`97`	`"IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code",`
`99`	`98`	`Justification = "Types registered for persistence are preserved in the API call to register them and typically live in assemblies that aren't trimmed.")]`
`100`		`- [DynamicDependency(LinkerFlags.JsonSerialized, typeof(PersistentComponentRegistration))]`
	`99`	`+ [DynamicDependency(LinkerFlags.JsonSerialized, typeof(PersistentServiceRegistration))]`
`101`	`100`	`internal void Restore(PersistentComponentState state)`
`102`	`101`	`{`
`103`		`- if (state.TryTakeFromJson<PersistentComponentRegistration[]>(_registryKey, out var registry) && registry != null)`
	`102`	`+ if (state.TryTakeFromJson<PersistentServiceRegistration[]>(_registryKey, out var registry) && registry != null)`
`104`	`103`	`{`
`105`	`104`	`_registrations = ResolveRegistrations(_registrations.Concat(registry));`
`106`	`105`	`}`
`@@ -141,9 +140,10 @@ private static void RestoreInstanceState(object instance, Type type, PersistentC`
`141`	`140`	`}`
`142`	`141`	`}`
`143`	`142`
`144`		`- private static IPersistentComponentRegistration[] ResolveRegistrations(IEnumerable<IPersistentComponentRegistration> registrations) => [.. registrations.DistinctBy(r => (r.Assembly, r.FullTypeName)).OrderBy(r => r.Assembly).ThenBy(r => r.FullTypeName)];`
	`143`	`+ private static IPersistentServiceRegistration[] ResolveRegistrations(IEnumerable<IPersistentServiceRegistration> registrations) => [.. registrations.DistinctBy(r => (r.Assembly, r.FullTypeName)).OrderBy(r => r.Assembly).ThenBy(r => r.FullTypeName)];`
`145`	`144`
`146`		`- private Type? ResolveType(string assembly, string fullTypeName) => _persistentServiceTypeCache.GetPersistentService(assembly, fullTypeName);`
	`145`	`+ private static Type? ResolveType(string assembly, string fullTypeName) =>`
	`146`	`+ _persistentServiceTypeCache.GetRootType(assembly, fullTypeName);`
`147`	`147`
`148`	`148`	`private sealed class PropertiesAccessor`
`149`	`149`	`{`
`@@ -217,7 +217,7 @@ internal static IEnumerable<PropertyInfo> GetCandidateBindableProperties(`
`217`	`217`	`}`
`218`	`218`
`219`	`219`	`[DebuggerDisplay($"{{{nameof(GetDebuggerDisplay)}(),nq}}")]`
`220`		`- private class PersistentComponentRegistration : IPersistentComponentRegistration`
	`220`	`+ private class PersistentServiceRegistration : IPersistentServiceRegistration`
`221`	`221`	`{`
`222`	`222`	`public string Assembly { get; set; } = "";`
`223`	`223`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ public static IServiceCollection AddSupplyValueFromPersistentComponentStateProvi`
`46`	`46`	`// We look for the type inside the assembly.`
`47`	`47`	`// We resolve the service from the DI container.`
`48`	`48`	`// We loop through the properties in the type and try to restore the properties that have SupplyParameterFromPersistentComponentState on them.`
`49`		`- services.TryAddEnumerable(ServiceDescriptor.Singleton<IPersistentComponentRegistration>(new PersistentComponentRegistration<TService>(componentRenderMode)));`
	`49`	`+ services.TryAddEnumerable(ServiceDescriptor.Singleton<IPersistentServiceRegistration>(new PersistentServiceRegistration<TService>(componentRenderMode)));`
`50`	`50`
`51`	`51`	`return services;`
`52`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -422,7 +422,7 @@ private class TestRenderMode : IComponentRenderMode`
`422`	`422`	`{`
`423`	`423`	`}`
`424`	`424`
`425`		`- private class PersistentService : IPersistentComponentRegistration`
	`425`	`+ private class PersistentService : IPersistentServiceRegistration`
`426`	`426`	`{`
`427`	`427`	`public string Assembly { get; set; }`
`428`	`428`