Add QueueDeleted event to IQueue<T> for queue deletion notifications

Adds a QueueDeleted async event raised after a queue is deleted via DeleteQueueAsync. This enables behaviors and event handlers to react to queue deletion (e.g., cleanup, logging, cache invalidation).

- Add QueueDeletedEventArgs<T> and QueueDeleted event to IQueue<T>
- Implement OnQueueDeletedAsync in QueueBase with parallel invocation
- Refactor DeleteQueueAsync into base class with DeleteQueueImplAsync pattern
- Move trace logging from InMemoryQueue to QueueBase for all implementations
- Wire QueueDeleted into QueueBehaviorBase for behavior support
- Dispose QueueDeleted event in QueueBase.Dispose
- Update queue documentation with QueueDeleted event and behavior examples

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

Author: niemyjski

docs/guide/queues.md

@@ -15,6 +15,7 @@ public interface IQueue<T> : IQueue where T : class
     AsyncEvent<LockRenewedEventArgs<T>> LockRenewed { get; }
     AsyncEvent<CompletedEventArgs<T>> Completed { get; }
     AsyncEvent<AbandonedEventArgs<T>> Abandoned { get; }
+    AsyncEvent<QueueDeletedEventArgs<T>> QueueDeleted { get; }
 
     void AttachBehavior(IQueueBehavior<T> behavior);
     Task<string> EnqueueAsync(T data, QueueEntryOptions options = null);
@@ -414,6 +415,11 @@ queue.Abandoned.AddHandler(async (sender, args) =>
 {
     _logger.LogWarning("Abandoned: {Id}", args.Entry.Id);
 });
+
+queue.QueueDeleted.AddHandler(async (sender, args) =>
+{
+    _logger.LogInformation("Queue deleted");
+});
 ```
 
 ## Queue Behaviors
@@ -454,6 +460,12 @@ public class LoggingQueueBehavior<T> : QueueBehaviorBase<T> where T : class
             args.Entry.Id, args.Entry.Attempts);
         return Task.CompletedTask;
     }
+
+    protected override Task OnQueueDeleted(object sender, QueueDeletedEventArgs<T> args)
+    {
+        _logger.LogInformation("Queue deleted");
+        return Task.CompletedTask;
+    }
 }
 
 // Attach to queue

src/Foundatio/Queues/IQueue.cs

@@ -46,6 +46,11 @@ public interface IQueue<T> : IQueue where T : class
     /// </summary>
     AsyncEvent<AbandonedEventArgs<T>> Abandoned { get; }
 
+    /// <summary>
+    /// Raised after the queue has been deleted.
+    /// </summary>
+    AsyncEvent<QueueDeletedEventArgs<T>> QueueDeleted { get; }
+
     /// <summary>
     /// Attaches a behavior that can intercept and modify queue operations.
     /// </summary>
@@ -326,3 +331,15 @@ public class AbandonedEventArgs<T> : EventArgs where T : class
     /// </summary>
     public IQueueEntry<T> Entry { get; set; }
 }
+
+/// <summary>
+/// Event arguments for the <see cref="IQueue{T}.QueueDeleted"/> event.
+/// </summary>
+/// <typeparam name="T">The type of message payload.</typeparam>
+public class QueueDeletedEventArgs<T> : EventArgs where T : class
+{
+    /// <summary>
+    /// The queue raising the event.
+    /// </summary>
+    public IQueue<T> Queue { get; set; }
+}

src/Foundatio/Queues/InMemoryQueue.cs

@@ -350,10 +350,8 @@ protected override Task<IEnumerable<T>> GetDeadletterItemsImplAsync(Cancellation
         return Task.FromResult(_deadletterQueue.Select(i => i.Value));
     }
 
-    public override Task DeleteQueueAsync()
+    protected override Task DeleteQueueImplAsync()
     {
-        _logger.LogTrace("Deleting queue: {QueueName} ({QueueId})", _options.Name, QueueId);
-
         _queue.Clear();
         _deadletterQueue.Clear();
         _dequeued.Clear();

src/Foundatio/Queues/QueueBase.cs

@@ -178,7 +178,14 @@ protected virtual QueueStats GetMetricsQueueStats()
         return GetQueueStatsAsync().AnyContext().GetAwaiter().GetResult();
     }
 
-    public abstract Task DeleteQueueAsync();
+    protected abstract Task DeleteQueueImplAsync();
+
+    public async Task DeleteQueueAsync()
+    {
+        _logger.LogTrace("Deleting queue: {QueueName} ({QueueId})", _options.Name, QueueId);
+        await DeleteQueueImplAsync().AnyContext();
+        await OnQueueDeletedAsync().AnyContext();
+    }
 
     protected abstract void StartWorkingImpl(Func<IQueueEntry<T>, CancellationToken, Task> handler, bool autoComplete, CancellationToken cancellationToken);
     public async Task StartWorkingAsync(Func<IQueueEntry<T>, CancellationToken, Task> handler, bool autoComplete = false, CancellationToken cancellationToken = default)
@@ -335,6 +342,17 @@ protected virtual async Task OnAbandonedAsync(IQueueEntry<T> entry)
         }
     }
 
+    public AsyncEvent<QueueDeletedEventArgs<T>> QueueDeleted { get; } = new AsyncEvent<QueueDeletedEventArgs<T>>(true);
+
+    protected virtual async Task OnQueueDeletedAsync()
+    {
+        if (QueueDeleted is not null)
+        {
+            var args = new QueueDeletedEventArgs<T> { Queue = this };
+            await QueueDeleted.InvokeAsync(this, args).AnyContext();
+        }
+    }
+
     protected string GetSubMetricName(T data)
     {
         var haveStatName = data as IHaveSubMetricName;
@@ -402,6 +420,7 @@ public override void Dispose()
         Enqueued?.Dispose();
         Enqueuing?.Dispose();
         LockRenewed?.Dispose();
+        QueueDeleted?.Dispose();
 
         foreach (var behavior in _behaviors.OfType<IDisposable>())
             behavior.Dispose();

src/Foundatio/Queues/QueueBehaviour.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
@@ -24,6 +24,7 @@ public virtual void Attach(IQueue<T> queue)
         _disposables.Add(_queue.LockRenewed.AddHandler(OnLockRenewed));
         _disposables.Add(_queue.Completed.AddHandler(OnCompleted));
         _disposables.Add(_queue.Abandoned.AddHandler(OnAbandoned));
+        _disposables.Add(_queue.QueueDeleted.AddHandler(OnQueueDeleted));
     }
 
     protected virtual Task OnEnqueuing(object sender, EnqueuingEventArgs<T> enqueuingEventArgs)
@@ -56,6 +57,11 @@ protected virtual Task OnAbandoned(object sender, AbandonedEventArgs<T> abandone
         return Task.CompletedTask;
     }
 
+    protected virtual Task OnQueueDeleted(object sender, QueueDeletedEventArgs<T> queueDeletedEventArgs)
+    {
+        return Task.CompletedTask;
+    }
+
     public virtual void Dispose()
     {
         foreach (var disposable in _disposables)

tests/Foundatio.Tests/Queue/InMemoryQueueTests.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Threading;
@@ -290,6 +290,57 @@ public async Task CanGetCompletedEntries()
         Assert.Equal(10, q.GetCompletedEntries().Count);
     }
 
+    [Fact]
+    public async Task DeleteQueueAsync_WithEventHandler_RaisesQueueDeletedEvent()
+    {
+        // Arrange
+        using var q = new InMemoryQueue<SimpleWorkItem>(o => o.LoggerFactory(Log));
+        bool eventFired = false;
+
+        using var handler = q.QueueDeleted.AddHandler((sender, args) =>
+        {
+            eventFired = true;
+            Assert.Same(q, args.Queue);
+            return Task.CompletedTask;
+        });
+
+        await q.EnqueueAsync(new SimpleWorkItem());
+
+        // Act
+        await q.DeleteQueueAsync();
+
+        // Assert
+        Assert.True(eventFired);
+    }
+
+    [Fact]
+    public async Task DeleteQueueAsync_WithAttachedBehavior_InvokesBehaviorOnQueueDeleted()
+    {
+        // Arrange
+        using var q = new InMemoryQueue<SimpleWorkItem>(o => o.LoggerFactory(Log));
+        var behavior = new QueueDeletedTestBehavior<SimpleWorkItem>();
+        q.AttachBehavior(behavior);
+
+        await q.EnqueueAsync(new SimpleWorkItem());
+
+        // Act
+        await q.DeleteQueueAsync();
+
+        // Assert
+        Assert.True(behavior.QueueDeletedCalled);
+    }
+
+    private class QueueDeletedTestBehavior<T> : QueueBehaviorBase<T> where T : class
+    {
+        public bool QueueDeletedCalled { get; private set; }
+
+        protected override Task OnQueueDeleted(object sender, QueueDeletedEventArgs<T> queueDeletedEventArgs)
+        {
+            QueueDeletedCalled = true;
+            return Task.CompletedTask;
+        }
+    }
+
     #region Issue239
 
     class QueueEntry_Issue239<T> : IQueueEntry<T> where T : class