how to use the publish-strategies of MediatR 12.0

I don’t understand how to use the publish-strategies of MediatR, can anyone give me an example?

public static async Task DispatchDomainEvents(this IMediator mediator, DbContext context,List<DomainEvent> deletedDomainEvents)
    {
        // If the delete domain events list has a value publish it first.
        if (deletedDomainEvents.Any())
        {
            foreach (var domainEvent in deletedDomainEvents)
                await mediator.Publish(domainEvent);
        }

        var entities = context.ChangeTracker
            .Entries<BaseEntity>()
            .Where(e => e.Entity.DomainEvents.Any())
            .Select(e => e.Entity);

        var domainEvents = entities
            .SelectMany(e => e.DomainEvents)
            .ToList();

        entities.ToList().ForEach(e => e.ClearDomainEvents());

        foreach (var domainEvent in domainEvents)
            await mediator.Publish(domainEvent);
    }

I want to use the PublishStrategy.ParallelNoWait strategy to send notifications.

[mkidsc1603]

Thanks, I resolve it !

    public class TestEvent: BaseEvent
    {
    }
    
    public abstract class BaseEvent : INotification
    {
        public PublishStrategy PublishStrategy { get; set; } = PublishStrategy.Async;
    }

    public enum PublishStrategy
    {
        SyncContinueOnException = 0,
        SyncStopOnException = 1,
        Async = 2,
        ParallelNoWait = 3,
        ParallelWhenAll = 4,
        ParallelWhenAny = 5,
    }

then publish like below:

await _mediator.Publish(new TestEvent() { PublishStrategy = PublishStrategy.ParallelNoWait }, cancellationToken);

Finally, CustomPublisher.cs

    internal class CustomPublisher : INotificationPublisher
    {
        public async Task Publish(IEnumerable<NotificationHandlerExecutor> handlerExecutors, INotification notification, CancellationToken cancellationToken)
        {
            if (notification is BaseEvent)
            {
                BaseEvent e = (BaseEvent)notification;

                if (e.PublishStrategy == PublishStrategy.Async)
                {
                    await AsyncContinueOnException(handlerExecutors, notification, cancellationToken);
                }
                else if (e.PublishStrategy == PublishStrategy.SyncStopOnException)
                {
                    await SyncStopOnException(handlerExecutors, notification, cancellationToken);
                }
                else if (e.PublishStrategy == PublishStrategy.SyncContinueOnException)
                {
                    await SyncContinueOnException(handlerExecutors, notification, cancellationToken);
                }
                else if(e.PublishStrategy == PublishStrategy.ParallelNoWait)
                {
                    ParallelNoWait(handlerExecutors, notification, cancellationToken);
                }
                else if (e.PublishStrategy == PublishStrategy.ParallelWhenAny)
                {
                    ParallelWhenAny(handlerExecutors, notification, cancellationToken);
                }
                else if(e.PublishStrategy == PublishStrategy.ParallelWhenAll)
                {
                    ParallelWhenAll(handlerExecutors, notification, cancellationToken);
                }
                else
                {
                    throw new ArgumentException("Unknown publish strategy.");
                }
            }
            else
            {
                throw new ArgumentException("Notification event class should inherit BaseEvent.");
            }
        }

        private Task ParallelWhenAll(IEnumerable<NotificationHandlerExecutor> handlers, INotification notification, CancellationToken cancellationToken)
        {
            var tasks = new List<Task>();

            foreach (var handler in handlers)
            {
                tasks.Add(Task.Run(() => handler.HandlerCallback(notification, cancellationToken)));
            }

            return Task.WhenAll(tasks);
        }

        private Task ParallelWhenAny(IEnumerable<NotificationHandlerExecutor> handlers, INotification notification, CancellationToken cancellationToken)
        {
            var tasks = new List<Task>();

            foreach (var handler in handlers)
            {
                tasks.Add(Task.Run(() => handler.HandlerCallback(notification, cancellationToken)));
            }

            return Task.WhenAny(tasks);
        }

        private Task ParallelNoWait(IEnumerable<NotificationHandlerExecutor> handlers, INotification notification, CancellationToken cancellationToken)
        {
            foreach (var handler in handlers)
            {
                Task.Run(() => handler.HandlerCallback(notification, cancellationToken));
            }

            return Task.CompletedTask;
        }

        private async Task AsyncContinueOnException(IEnumerable<NotificationHandlerExecutor> handlers, INotification notification, CancellationToken cancellationToken)
        {
            var tasks = new List<Task>();
            var exceptions = new List<Exception>();

            foreach (var handler in handlers)
            {
                try
                {
                    tasks.Add(handler.HandlerCallback(notification, cancellationToken));
                }
                catch (Exception ex) when (!(ex is OutOfMemoryException || ex is StackOverflowException))
                {
                    exceptions.Add(ex);
                }
            }

            try
            {
                await Task.WhenAll(tasks).ConfigureAwait(false);
            }
            catch (AggregateException ex)
            {
                exceptions.AddRange(ex.Flatten().InnerExceptions);
            }
            catch (Exception ex) when (!(ex is OutOfMemoryException || ex is StackOverflowException))
            {
                exceptions.Add(ex);
            }

            if (exceptions.Any())
            {
                throw new AggregateException(exceptions);
            }
        }

        private async Task SyncStopOnException(IEnumerable<NotificationHandlerExecutor> handlers, INotification notification, CancellationToken cancellationToken)
        {
            foreach (var handler in handlers)
            {
                await handler.HandlerCallback(notification, cancellationToken).ConfigureAwait(false);
            }
        }

        private async Task SyncContinueOnException(IEnumerable<NotificationHandlerExecutor> handlers, INotification notification, CancellationToken cancellationToken)
        {
            var exceptions = new List<Exception>();

            foreach (var handler in handlers)
            {
                try
                {
                    await handler.HandlerCallback(notification, cancellationToken).ConfigureAwait(false);
                }
                catch (AggregateException ex)
                {
                    exceptions.AddRange(ex.Flatten().InnerExceptions);
                }
                catch (Exception ex) when (!(ex is OutOfMemoryException || ex is StackOverflowException))
                {
                    exceptions.Add(ex);
                }
            }

            if (exceptions.Any())
            {
                throw new AggregateException(exceptions);
            }
        }
    }

[neozhu]

Thank you for your reply. if I want to use PublishStrategy.ParallelNoWait: Can I write this right?

public class ParallelNoWaitPublisher : INotificationPublisher
{
    public Task Publish(IEnumerable<NotificationHandlerExecutor> handlerExecutors, INotification notification, CancellationToken cancellationToken)
    {
        foreach (var handler in handlerExecutors)
        {
            Task.Run(() => handler.HandlerCallback(notification, cancellationToken));
        }

        return Task.CompletedTask;
    }
}