Merge pull request #453 from TimeWarpEngineering/Cramer/2024-07-25/Next

Add RegisterRenderTrigger that takes an Expression and caches complied version

Directory.Build.props

@@ -1,7 +1,7 @@
 <Project>
   <!-- Set common properties regarding assembly information and nuget packages -->
   <PropertyGroup>
-    <TimeWarpStateVersion>11.0.0-beta.68+8.0.303</TimeWarpStateVersion>
+    <TimeWarpStateVersion>11.0.0-beta.69+8.0.303</TimeWarpStateVersion>
     <Authors>Steven T. Cramer</Authors>
     <Product>TimeWarp State</Product>
     <PackageVersion>$(TimeWarpStateVersion)</PackageVersion>

Source/TimeWarp.State/Components/TimeWarpStateComponent.cs

@@ -33,6 +33,7 @@ public class TimeWarpStateComponent : ComponentBase, IDisposable, ITimeWarpState
   [Parameter] public string? TestId { get; set; }
 
   private readonly ConcurrentDictionary <Type, Func<bool>> RenderTriggers = new();
+  private readonly ConcurrentDictionary<(Type StateType, string PropertyName), Func<object, object, bool>> CompiledPropertyComparisons = new();
 
   /// <summary>
   /// Set this to true if something in the component has changed that requires a re-render.
@@ -176,6 +177,59 @@ protected void RegisterRenderTrigger<T>(Func<T, bool> triggerCondition) where T
     RenderTriggers[typeof(T)] = () => ShouldReRender(typeof(T), triggerCondition);
   }
 
+  /// <summary>
+    /// Registers a render trigger for a specific state type using a property selector expression.
+    /// </summary>
+    /// <typeparam name="TState">The type of state to monitor. Must be a reference type.</typeparam>
+    /// <param name="propertySelector">An expression that selects the property to monitor for changes.</param>
+    /// <remarks>
+    /// This method creates a render trigger that compares a specific property of the state object.
+    /// It uses expression trees to build an efficient comparison function, which is cached for subsequent use.
+    /// The component will re-render when the selected property's value changes.
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// RegisterRenderTrigger&lt;CounterState&gt;(s => s.Count);
+    /// </code>
+    /// </example>
+    /// <exception cref="ArgumentNullException">Thrown when the propertySelector is null.</exception>
+    /// <exception cref="ArgumentException">Thrown when the propertySelector does not represent a simple property access.</exception>
+    protected void RegisterRenderTrigger<TState>(Expression<Func<TState, object>> propertySelector) 
+        where TState : class
+    {
+        ArgumentNullException.ThrowIfNull(propertySelector);
+
+        MemberExpression? memberExpression = propertySelector.Body as MemberExpression 
+            ?? ((UnaryExpression)propertySelector.Body).Operand as MemberExpression;
+
+        if (memberExpression == null)
+        {
+            throw new ArgumentException("Property selector must be a simple property access expression.", nameof(propertySelector));
+        }
+
+        var property = (PropertyInfo)memberExpression.Member;
+
+        Func<object, object, bool> comparisonFunc = CompiledPropertyComparisons.GetOrAdd((typeof(TState), property.Name), _ =>
+        {
+            ParameterExpression previousParam = Expression.Parameter(typeof(object), "previous");
+            ParameterExpression currentParam = Expression.Parameter(typeof(object), "current");
+
+            BinaryExpression notEqualExpression = Expression.NotEqual(
+                Expression.Property(Expression.Convert(previousParam, typeof(TState)), property),
+                Expression.Property(Expression.Convert(currentParam, typeof(TState)), property)
+            );
+
+            return Expression.Lambda<Func<object, object, bool>>(notEqualExpression, previousParam, currentParam).Compile();
+        });
+
+        RenderTriggers[typeof(TState)] = () => 
+        {
+            TState? previousState = GetPreviousState<TState>();
+            TState currentState = GetState<TState>(false);
+            return previousState == null || comparisonFunc(previousState, currentState);
+        };
+    }
+
   /// <summary>
   ///   Place a Subscription for the calling component
   ///   And returns the requested state 

Source/TimeWarp.State/Components/TimeWarpStateComponent.md

@@ -17,7 +17,7 @@ The `TimeWarpStateComponent` is a crucial base class in the TimeWarp.State libra
 ### 2. Instance Tracking
 
 - Generates a unique `Id` for each component instance
-- The primary purpose of the ID is for placing of subscriptions
+- The `Id` serves as a unique key in the subscription system
 - Also useful for debugging and component identification
 
 ### 3. Render Mode Management

Source/TimeWarp.State/GlobalUsings.cs

@@ -21,6 +21,7 @@
 global using System.Text.RegularExpressions;
 global using System.Text;
 global using System;
+global using System.Linq.Expressions;
 global using TimeWarp.Features.Developer;
 global using TimeWarp.Features.JavaScriptInterop;
 global using TimeWarp.Features.ReduxDevTools;

Tests/Test.App/Test.App.Client/Features/Counter/Components/Counter.razor

@@ -1,6 +1,16 @@
 @namespace Test.App.Client.Features.Counter.Components
 @inherits BaseComponent
 
+@code 
+{
+  protected override void OnInitialized()
+  {
+    RegisterRenderTrigger<CounterState>(p => p.Count != CounterState.Count);
+    RegisterRenderTrigger<CounterState>(p => p.Count);
+    base.OnInitialized();
+  }
+}
+
 <div data-qa="@TestId">
   <p>CounterState.Count: <span data-qa="count">@CounterState.Count</span></p>