Synchronize lifecycle for triggers attached after load

docfx/articles/interactivity/behaviors.md

@@ -93,6 +93,8 @@ In many cases, a behavior needs to perform actions not just when it is attached,
 
 When you attach a behavior collection to a control, the `Interaction` class subscribes to relevant events on that control (like `AttachedToVisualTree`, `DetachedFromVisualTree`, `Loaded`, `Unloaded`, etc.). When these events fire, `Interaction` iterates through the behaviors in the collection and calls the corresponding lifecycle method on each behavior.
 
+If a collection or an individual behavior is attached after the control is already initialized, rooted, or loaded, the current lifecycle state is synchronized immediately. In particular, `OnLoaded` runs once for that current loaded lifetime instead of waiting for the control to unload and load again.
+
 *   **`OnAttached`**: Called when the behavior is attached to an object. Use this method to subscribe to events or initialize the behavior.
 *   **`OnDetaching`**: Called when the behavior is detached from an object. Use this method to unsubscribe from events and clean up resources.
 

src/Xaml.Behaviors.Interactivity/AvaloniaObject/Behavior.cs

@@ -12,6 +12,11 @@ namespace Avalonia.Xaml.Interactivity;
 /// </summary>
 public abstract class Behavior : AvaloniaObject, IBehavior, IBehaviorEventsHandler
 {
+    private bool _isAttachedToLogicalTree;
+    private bool _isAttachedToVisualTree;
+    private bool _isInitializedNotified;
+    private bool _isLoaded;
+
     /// <summary>
     /// Identifies the <seealso cref="IsEnabled"/> avalonia property.
     /// </summary>
@@ -64,6 +69,10 @@ public void Attach(AvaloniaObject? associatedObject)
     public void Detach()
     {
         OnDetaching();
+        _isAttachedToLogicalTree = false;
+        _isAttachedToVisualTree = false;
+        _isInitializedNotified = false;
+        _isLoaded = false;
         AssociatedObject = null;
     }
 
@@ -87,19 +96,82 @@ protected virtual void OnDetaching()
     {
     }
 
-    void IBehaviorEventsHandler.AttachedToVisualTreeEventHandler() => OnAttachedToVisualTree();
+    void IBehaviorEventsHandler.AttachedToVisualTreeEventHandler()
+    {
+        if (_isAttachedToVisualTree)
+        {
+            return;
+        }
 
-    void IBehaviorEventsHandler.DetachedFromVisualTreeEventHandler() => OnDetachedFromVisualTree();
+        _isAttachedToVisualTree = true;
+        OnAttachedToVisualTree();
+    }
+
+    void IBehaviorEventsHandler.DetachedFromVisualTreeEventHandler()
+    {
+        if (!_isAttachedToVisualTree)
+        {
+            return;
+        }
 
-    void IBehaviorEventsHandler.AttachedToLogicalTreeEventHandler() => OnAttachedToLogicalTree();
+        _isAttachedToVisualTree = false;
+        OnDetachedFromVisualTree();
+    }
 
-    void IBehaviorEventsHandler.DetachedFromLogicalTreeEventHandler() => OnDetachedFromLogicalTree();
+    void IBehaviorEventsHandler.AttachedToLogicalTreeEventHandler()
+    {
+        if (_isAttachedToLogicalTree)
+        {
+            return;
+        }
 
-    void IBehaviorEventsHandler.LoadedEventHandler() => OnLoaded();
+        _isAttachedToLogicalTree = true;
+        OnAttachedToLogicalTree();
+    }
 
-    void IBehaviorEventsHandler.UnloadedEventHandler() => OnUnloaded();
+    void IBehaviorEventsHandler.DetachedFromLogicalTreeEventHandler()
+    {
+        if (!_isAttachedToLogicalTree)
+        {
+            return;
+        }
 
-    void IBehaviorEventsHandler.InitializedEventHandler() => OnInitializedEvent();
+        _isAttachedToLogicalTree = false;
+        OnDetachedFromLogicalTree();
+    }
+
+    void IBehaviorEventsHandler.LoadedEventHandler()
+    {
+        if (_isLoaded)
+        {
+            return;
+        }
+
+        _isLoaded = true;
+        OnLoaded();
+    }
+
+    void IBehaviorEventsHandler.UnloadedEventHandler()
+    {
+        if (!_isLoaded)
+        {
+            return;
+        }
+
+        _isLoaded = false;
+        OnUnloaded();
+    }
+
+    void IBehaviorEventsHandler.InitializedEventHandler()
+    {
+        if (_isInitializedNotified)
+        {
+            return;
+        }
+
+        _isInitializedNotified = true;
+        OnInitializedEvent();
+    }
 
     void IBehaviorEventsHandler.DataContextChangedEventHandler() => OnDataContextChangedEvent();