Do not update properties when updated after restoring

Author: javiercn

src/Components/Components/src/PersistentState/RestoreStateOnPrerenderingAttribute.cs

@@ -1,6 +1,8 @@
 // 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;
 
 /// <summary>
@@ -20,26 +22,27 @@ namespace Microsoft.AspNetCore.Components;
 /// public string? NonPrerenderingData { get; set; }
 /// </code>
 /// </example>
+/// <remarks>
+/// Initializes a new instance of the <see cref="RestoreStateOnPrerenderingAttribute"/> class.
+/// </remarks>
+/// <param name="enable">
+/// <see langword="true"/> to enable state restoration during prerendering (default);
+/// <see langword="false"/> to disable state restoration during prerendering.
+/// </param>
 [AttributeUsage(AttributeTargets.Property)]
-public sealed class RestoreStateOnPrerenderingAttribute : Attribute, IPersistentStateFilter
+[DebuggerDisplay($"{{{nameof(GetDebuggerDisplay)}(),nq}}")]
+public sealed class RestoreStateOnPrerenderingAttribute(bool enable = true) : Attribute, IPersistentStateFilter
 {
-    /// <summary>
-    /// Initializes a new instance of the <see cref="RestoreStateOnPrerenderingAttribute"/> class.
-    /// </summary>
-    /// <param name="enable">
-    /// <see langword="true"/> to enable state restoration during prerendering (default);
-    /// <see langword="false"/> to disable state restoration during prerendering.
-    /// </param>
-    public RestoreStateOnPrerenderingAttribute(bool enable = true)
-    {
-        Filter = enable ? WebPersistenceFilter.Prerendering : new WebPersistenceFilter(WebPersistenceScenarioType.Prerendering, enabled: false);
-    }
-
-    internal WebPersistenceFilter Filter { get; }
+    internal WebPersistenceFilter Filter { get; } = enable ? WebPersistenceFilter.Prerendering : new WebPersistenceFilter(WebPersistenceScenarioType.Prerendering, enabled: false);
 
     bool IPersistentStateFilter.SupportsScenario(IPersistentComponentStateScenario scenario)
         => Filter.SupportsScenario(scenario);
 
     bool IPersistentStateFilter.ShouldRestore(IPersistentComponentStateScenario scenario)
         => Filter.ShouldRestore(scenario);
+
+    private string GetDebuggerDisplay()
+    {
+        return $"RestoreStateOnPrerenderingAttribute: (Enabled: {enable})";
+    }
 }

src/Components/Components/src/PersistentStateValueProvider.cs

@@ -394,10 +394,12 @@ public bool SupportsScenario(IPersistentComponentStateScenario scenario)
 
     internal class ComponentSubscription
     {
+        private static readonly object _uninitializedValue = new();
         private readonly PersistingComponentStateSubscription? _persistingSubscription;
         private readonly RestoringComponentStateSubscription? _restoringSubscription;
-        private object? _lastValue;
-        private bool _hasComputedValueFirstTime;
+        private object? _lastValue = _uninitializedValue;
+        private bool _hasPendingInitialValue;
+        private bool _ignoreUpdatedValues;
         private readonly PersistentComponentState _state;
         private readonly ComponentState _subscriber;
         private readonly string _propertyName;
@@ -434,45 +436,38 @@ public ComponentSubscription(
 
         internal object? GetOrComputeLastValue()
         {
-            if (!_hasComputedValueFirstTime)
+            var isInitialized = !ReferenceEquals(_lastValue, _uninitializedValue);
+            if (!isInitialized)
             {
-                _hasComputedValueFirstTime = true;
-                RestoreProperty();
-            }
-
-            return _lastValue;
-        }
-
-        [UnconditionalSuppressMessage("Trimming", "IL2075:'this' argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The return value of the source method does not have matching annotations.", Justification = "OpenComponent already has the right set of attributes")]
-        [UnconditionalSuppressMessage("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", Justification = "OpenComponent already has the right set of attributes")]
-        [UnconditionalSuppressMessage("Trimming", "IL2072:Target parameter argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The return value of the source method does not have matching annotations.", Justification = "OpenComponent already has the right set of attributes")]
-        [UnconditionalSuppressMessage("Trimming", "IL2077:'type' argument does not satisfy 'DynamicallyAccessedMemberTypes' in call to target method. The source field does not have matching annotations.", Justification = "Property types on components are preserved through other means.")]
-        private Task PersistProperty()
-        {
-            // The key needs to be computed here, do not move this outside of the lambda.
-            var storageKey = ComputeKey(_subscriber, _propertyName);
-
-            var property = _propertyGetter.GetValue(_subscriber.Component);
-            if (property == null)
-            {
-                Log.SkippedPersistingNullValue(_logger, storageKey, _propertyType.Name, _subscriber.Component.GetType().Name, _propertyName);
-                return Task.CompletedTask;
+                // Remove the uninitialized sentinel.
+                _lastValue = null;
+                if (_hasPendingInitialValue)
+                {
+                    RestoreProperty();
+                    _hasPendingInitialValue = false;
+                }
             }
-
-            if (_customSerializer != null)
+            else
             {
-                Log.PersistingValueToState(_logger, storageKey, _propertyType.Name, _subscriber.Component.GetType().Name, _propertyName);
-
-                using var writer = new PooledArrayBufferWriter<byte>();
-                _customSerializer.Persist(_propertyType, property, writer);
-                _state.PersistAsBytes(storageKey, writer.WrittenMemory.ToArray());
-                return Task.CompletedTask;
+                if (_ignoreUpdatedValues)
+                {
+                    // At this point, we just received a value update from `RestoreProperty`.
+                    // The property value might have been modified by the component and in this
+                    // case we want to overwrite it with the value we just restored.
+                    _ignoreUpdatedValues = false;
+                    return _lastValue;
+                }
+                else
+                {
+                    // In this case, the component might have modified the property value after
+                    // we restored it from the persistent state. We don't want to overwrite it
+                    // with a previously restored value.
+                    var currentPropertyValue = _propertyGetter.GetValue(_subscriber.Component);
+                    return currentPropertyValue;
+                }
             }
 
-            // Fallback to JSON serialization
-            Log.PersistingValueToState(_logger, storageKey, _propertyType.Name, _subscriber.Component.GetType().Name, _propertyName);
-            _state.PersistAsJson(storageKey, property, _propertyType);
-            return Task.CompletedTask;
+            return _lastValue;
         }
 
         [UnconditionalSuppressMessage("Trimming", "IL2075:'this' argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The return value of the source method does not have matching annotations.", Justification = "OpenComponent already has the right set of attributes")]
@@ -481,12 +476,14 @@ private Task PersistProperty()
         [UnconditionalSuppressMessage("Trimming", "IL2077:'type' argument does not satisfy 'DynamicallyAccessedMemberTypes' in call to target method. The source field does not have matching annotations.", Justification = "Property types on components are preserved through other means.")]
         private void RestoreProperty()
         {
-            if (!_hasComputedValueFirstTime)
+            var skipNotifications = _hasPendingInitialValue;
+            if (ReferenceEquals(_lastValue, _uninitializedValue) && !_hasPendingInitialValue)
             {
-                // We'll get invoked right away upon subscription. This is too early to try and restore the value as
-                // the component state might not be fully initialized yet.
-                // For that reason, skip the restore operation until GetOrComputeLastValue is called.
-                // It will trigger the restore operation at the right time.
+                // Upon subscribing, the callback might be invoked right away,
+                // but this is too early to restore the first value since the component state
+                // hasn't been fully initialized yet.
+                // For that reason, we make a mark to restore the state on GetOrComputeLastValue.
+                _hasPendingInitialValue = true;
                 return;
             }
 
@@ -500,7 +497,11 @@ private void RestoreProperty()
                     Log.RestoringValueFromState(_logger, storageKey, _propertyType.Name, _propertyName);
                     var sequence = new ReadOnlySequence<byte>(data!);
                     _lastValue = _customSerializer.Restore(_propertyType, sequence);
-                    _subscriber.NotifyCascadingValueChanged(ParameterViewLifetime.Unbound);
+                    if (!skipNotifications)
+                    {
+                        _ignoreUpdatedValues = true;
+                        _subscriber.NotifyCascadingValueChanged(ParameterViewLifetime.Unbound);
+                    }
                 }
                 else
                 {
@@ -513,7 +514,11 @@ private void RestoreProperty()
                 {
                     Log.RestoredValueFromPersistentState(_logger, storageKey, _propertyType.Name, "null", _propertyName);
                     _lastValue = value;
-                    _subscriber.NotifyCascadingValueChanged(ParameterViewLifetime.Unbound);
+                    if (!skipNotifications)
+                    {
+                        _ignoreUpdatedValues = true;
+                        _subscriber.NotifyCascadingValueChanged(ParameterViewLifetime.Unbound);
+                    }
                 }
                 else
                 {
@@ -522,6 +527,38 @@ private void RestoreProperty()
             }
         }
 
+        [UnconditionalSuppressMessage("Trimming", "IL2075:'this' argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The return value of the source method does not have matching annotations.", Justification = "OpenComponent already has the right set of attributes")]
+        [UnconditionalSuppressMessage("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", Justification = "OpenComponent already has the right set of attributes")]
+        [UnconditionalSuppressMessage("Trimming", "IL2072:Target parameter argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The return value of the source method does not have matching annotations.", Justification = "OpenComponent already has the right set of attributes")]
+        [UnconditionalSuppressMessage("Trimming", "IL2077:'type' argument does not satisfy 'DynamicallyAccessedMemberTypes' in call to target method. The source field does not have matching annotations.", Justification = "Property types on components are preserved through other means.")]
+        private Task PersistProperty()
+        {
+            // The key needs to be computed here, do not move this outside of the lambda.
+            var storageKey = ComputeKey(_subscriber, _propertyName);
+
+            var property = _propertyGetter.GetValue(_subscriber.Component);
+            if (property == null)
+            {
+                Log.SkippedPersistingNullValue(_logger, storageKey, _propertyType.Name, _subscriber.Component.GetType().Name, _propertyName);
+                return Task.CompletedTask;
+            }
+
+            if (_customSerializer != null)
+            {
+                Log.PersistingValueToState(_logger, storageKey, _propertyType.Name, _subscriber.Component.GetType().Name, _propertyName);
+
+                using var writer = new PooledArrayBufferWriter<byte>();
+                _customSerializer.Persist(_propertyType, property, writer);
+                _state.PersistAsBytes(storageKey, writer.WrittenMemory.ToArray());
+                return Task.CompletedTask;
+            }
+
+            // Fallback to JSON serialization
+            Log.PersistingValueToState(_logger, storageKey, _propertyType.Name, _subscriber.Component.GetType().Name, _propertyName);
+            _state.PersistAsJson(storageKey, property, _propertyType);
+            return Task.CompletedTask;
+        }
+
         public void Dispose()
         {
             _persistingSubscription?.Dispose();