MediatR - 1.1

using MediatR;
using Microsoft.Extensions.DependencyInjection;

public class Benchmarks
{
    private IMediator _mediator;
    private readonly Pinged _notification = new Pinged();

    public void GlobalSetup()
    {
        var services = new ServiceCollection();
        services.AddMediatR(cfg =>
        {
            cfg.RegisterServicesFromAssemblyContaining(typeof(Ping));
        });
        var provider = services.BuildServiceProvider();
        _mediator = provider.GetRequiredService<IMediator>();
    }

    public Task PublishingNotifications()
    {
        return _mediator.Publish(_notification);
    }
}

private static async Task<bool> IsHandlerForLessSpecificExceptionWorks(IMediator mediator, WrappingWriter writer)
    {
        var isHandledCorrectly = false;

        await writer.WriteLineAsync("Checking base handler to catch any exception...");
        try
        {
            await mediator.Send(new PingResourceTimeout { Message = "Ping to ISS resource" });
            isHandledCorrectly = IsExceptionHandledBy<TaskCanceledException, CommonExceptionHandler> (writer);
        }
        catch (Exception e)
        {
            await writer.WriteLineAsync(e.Message);
        }
        await writer.WriteLineAsync();

        return isHandledCorrectly;
    }

public async Task Should_register_and_wrap_with_behavior()
    {
        var output = new Logger();
        IServiceCollection services = new ServiceCollection();
        services.AddSingleton(output);
        services.AddMediatR(cfg =>
        {
            cfg.RegisterServicesFromAssembly(typeof(Ping).Assembly);
            cfg.
        });
        var provider = services.BuildServiceProvider();

        var mediator = provider.GetRequiredService<IMediator>();

        var stream = mediator.CreateStream(new StreamPing { Message = "Ping" });

        await foreach (var response in stream)
        {
            response.Message.ShouldBe("Ping Pang");
        }
    }

public Task Should_raise_execption_on_null_request() => Should.ThrowAsync<ArgumentNullException>(async () => await _mediator.Send(default!));

using FluentMediator;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class TaskService : ITaskService
{
    private readonly ITaskRepository _taskRepository;
    private readonly ITaskFactory _taskFactory;
    private readonly TaskViewModelMapper _taskViewModelMapper;
    private readonly ITracer _tracer;
    private readonly IMediator _mediator;

    public TaskService(ITaskRepository taskRepository, TaskViewModelMapper taskViewModelMapper, ITracer tracer, ITaskFactory taskFactory, IMediator mediator)
    {
        _taskRepository = taskRepository;
        _taskViewModelMapper = taskViewModelMapper;
        _tracer = tracer;
        _taskFactory = taskFactory;
        _mediator = mediator;
    }

    public async System.Threading.Tasks.Task Delete(Guid id)
    {
        using (var scope = _tracer.BuildSpan("Delete_TaskService").StartActive(true))
        {
            var deleteTaskCommand = _taskViewModelMapper.ConvertToDeleteTaskCommand(id);
            await _mediator.PublishAsync(deleteTaskCommand);
        }
    }
}

using System;
using System.Threading.Tasks;
using Mediator.Net
using Microsoft.AspNetCore.Mvc;

[Route("api/[controller]")]
public class ValuesController : Controller
{
    private readonly IMediator _mediator;

    public ValuesController(IMediator mediator)
    {
        _mediator = mediator;
    }

    [HttpPost]
    [Route(("event"))]
    public async Task PostEvent(int id, [FromBody]EventData value)
    {
        await _mediator.PublishAsync(new ResultCalculatedEvent(value.Result));
    }
    
}

using Handyman.Mediator;
using Microsoft.Extensions.DependencyInjection;

public class PublisherSample : Sample
{
   public override async Task RunAsync(CancellationToken cancellationToken)
   {
      var mediator = ServiceProvider.GetRequiredService<IPublisher<Event>>();

      var @event = new Event();

      await mediator.Publish(@event, cancellationToken);
   }
}

using MediatR;

public class PingedHandler : INotificationHandler<Pinged>
{
    public Task Handle(Pinged notification, CancellationToken cancellationToken)
    {
        return Task.CompletedTask;
    }
}

using MediatR;

public class PingResourceTimeoutHandler : IRequestHandler<PingResourceTimeout, Pong>
{
    private readonly TextWriter _writer;

    public PingResourceTimeoutHandler(TextWriter writer) => _writer = writer;

    public Task<Pong> Handle(PingResourceTimeout request, CancellationToken cancellationToken)
    {
        throw new TaskCanceledException();
    }
}

using MediatR;

public class PingStreamHandler : IStreamRequestHandler<StreamPing, Pong>
    {
        private readonly Logger _output;

        public PingStreamHandler(Logger output)
        {
            _output = output;
        }
        public async IAsyncEnumerable<Pong> Handle(StreamPing request, [EnumeratorCancellation] CancellationToken cancellationToken)
        {
            _output.Messages.Add("Handler");
            yield return await Task.Run(() => new Pong { Message = request.Message + " Pang" }, cancellationToken);
        }
    }

using System;
using System.Collections.Generic;

using FluentMediator;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;


public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

    // This method gets called by the runtime. Use this method to add services to the container.
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllers();

        services.AddScoped<TaskCommandHandler>();
        services.AddScoped<TaskEventHandler>();

        services.AddFluentMediator(builder =>
        {
            builder.On<CreateNewTaskCommand>().PipelineAsync().Return<Domain.Tasks.Task, TaskCommandHandler>((handler, request) => handler.HandleNewTask(request));

            builder.On<TaskCreatedEvent>().PipelineAsync().Call<TaskEventHandler>((handler, request) => handler.HandleTaskCreatedEvent(request));

            builder.On<DeleteTaskCommand>().PipelineAsync().Call<TaskCommandHandler>((handler, request) => handler.HandleDeleteTask(request));

            builder.On<TaskDeletedEvent>().PipelineAsync().Call<TaskEventHandler>((handler, request) => handler.HandleTaskDeletedEvent(request));
        });

    }
    }

using Mediator.Net.Context;
using Mediator.Net.Contracts;
using Mediator.Net.WebApiSample.Handlers.CommandHandler;

namespace Mediator.Net.WebApiSample.Handlers.EventHandler
{
    public class ResultCalculatedEventHandler: IEventHandler<ResultCalculatedEvent>
    {
        private readonly IBoardcastService _boardcastService;

        public ResultCalculatedEventHandler(IBoardcastService boardcastService)
        {
            _boardcastService = boardcastService;
        }
        public Task Handle(IReceiveContext<ResultCalculatedEvent> context, CancellationToken cancellationToken)
        {
            _boardcastService.Boardcast(context.Message.Result);
            return Task.FromResult(0);
        }
    }
}

using Handyman.Mediator;
using Microsoft.Extensions.DependencyInjection;

public class Handler : IEventHandler<Event>
{
   public async Task Handle(Event @event, CancellationToken cancellationToken)
   {
      await Task.Yield();

      Console.WriteLine(GetType().Name);
   }
}