Add QueueException and guard against reusing behavior instances

Add QueueException following the established pattern (CacheException, StorageException, MessageBusException) to provide a consistent exception type for queue operations.

Add a guard in QueueBehaviorBase.Attach that throws QueueException if the behavior is already attached to a queue, preventing subtle bugs from duplicate event handler subscriptions or stale queue references.

Include documentation updates in docs/guide/queues.md with behavior attachment rules and QueueException usage, plus two new tests following naming standards.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: niemyjski

docs/guide/queues.md

@@ -511,8 +511,25 @@ await queue.EnqueueAsync(new OrderWorkItem { OrderId = 456 }); // ✅ Enqueued
 3. If not found, the identifier is cached with the specified TTL
 4. On dequeue, the identifier is removed from the cache (allowing re-submission)
 
+### Behavior Attachment Rules
+
+Each behavior instance can only be attached to a single queue. Attempting to attach the same behavior instance to multiple queues or attaching it twice to the same queue throws a `QueueException`. This prevents subtle bugs where event handlers could fire against the wrong queue reference.
+
+```csharp
+// ✅ Correct: separate instances for each queue
+queue1.AttachBehavior(new LoggingQueueBehavior<WorkItem>(logger));
+queue2.AttachBehavior(new LoggingQueueBehavior<WorkItem>(logger));
+
+// ❌ Throws QueueException: same instance attached twice
+var behavior = new LoggingQueueBehavior<WorkItem>(logger);
+queue1.AttachBehavior(behavior);
+queue2.AttachBehavior(behavior); // throws QueueException
+```
+
 ### Attaching Multiple Behaviors
 
+You can attach multiple different behavior instances to a single queue:
+
 ```csharp
 var queue = new InMemoryQueue<WorkItem>(o => o
     .Behaviors(
@@ -751,6 +768,26 @@ services.AddSingleton<IQueue<EmailWorkItem>>(sp =>
     new InMemoryQueue<EmailWorkItem>(o => o.Name = "emails"));
 ```
 
+## Queue Exceptions
+
+Queue operations throw `QueueException` for queue-specific error conditions. This provides a consistent, predictable exception type across all queue implementations (in-memory, Redis, Azure, AWS, etc.).
+
+```csharp
+using Foundatio.Queues;
+
+try
+{
+    // Attempting to reuse a behavior instance throws QueueException
+    var behavior = new LoggingQueueBehavior<WorkItem>(logger);
+    queue1.AttachBehavior(behavior);
+    queue2.AttachBehavior(behavior); // throws QueueException
+}
+catch (QueueException ex)
+{
+    logger.LogError(ex, "Queue operation failed: {Message}", ex.Message);
+}
+```
+
 ## Best Practices
 
 ### 1. Proper Resource Disposal

src/Foundatio/Queues/QueueBehaviour.cs

@@ -16,6 +16,11 @@ public abstract class QueueBehaviorBase<T> : IQueueBehavior<T>, IDisposable wher
 
     public virtual void Attach(IQueue<T> queue)
     {
+        ArgumentNullException.ThrowIfNull(queue);
+
+        if (_queue is not null)
+            throw new QueueException("This behavior is already attached to a queue. Create a separate behavior instance for each queue.");
+
         _queue = queue;
 
         _disposables.Add(_queue.Enqueuing.AddHandler(OnEnqueuing));

src/Foundatio/Queues/QueueException.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace Foundatio.Queues;
+
+/// <summary>
+/// Exception thrown for queue operation errors.
+/// </summary>
+public class QueueException : Exception
+{
+    public QueueException(string message) : base(message)
+    {
+    }
+
+    public QueueException(string message, Exception innerException) : base(message, innerException)
+    {
+    }
+}

tests/Foundatio.Tests/Queue/InMemoryQueueTests.cs

@@ -330,6 +330,30 @@ public async Task DeleteQueueAsync_WithAttachedBehavior_InvokesBehaviorOnQueueDe
         Assert.True(behavior.QueueDeletedCalled);
     }
 
+    [Fact]
+    public void AttachBehavior_WhenAlreadyAttached_ThrowsQueueException()
+    {
+        // Arrange
+        using var q1 = new InMemoryQueue<SimpleWorkItem>(o => o.LoggerFactory(Log));
+        using var q2 = new InMemoryQueue<SimpleWorkItem>(o => o.LoggerFactory(Log));
+        var behavior = new QueueDeletedTestBehavior<SimpleWorkItem>();
+        q1.AttachBehavior(behavior);
+
+        // Act & Assert
+        var ex = Assert.Throws<QueueException>(() => q2.AttachBehavior(behavior));
+        Assert.Contains("already attached", ex.Message);
+    }
+
+    [Fact]
+    public void AttachBehavior_WithNullQueue_ThrowsArgumentNullException()
+    {
+        // Arrange
+        var behavior = new QueueDeletedTestBehavior<SimpleWorkItem>();
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() => behavior.Attach(null));
+    }
+
     private class QueueDeletedTestBehavior<T> : QueueBehaviorBase<T> where T : class
     {
         public bool QueueDeletedCalled { get; private set; }