using System;

using MediatR;

using MediatR.Pipeline;

using System.Threading.Tasks;

using System.Threading;

using Microsoft.Extensions.DependencyInjection;

using Ardalis.Result;

using System.Collections.Generic;

​

public class Program

{

    static async Task Main()

    {

        var services = new ServiceCollection();

​

​

        services.AddMediatR(cfg =>

        {

            cfg.RegisterServicesFromAssemblies(typeof(EnableLdapAccountCommand).Assembly);

            cfg.AddOpenRequestPostProcessor(typeof(StepRecorderingRequestPostProcessor<,>));

        });

        services.AddTransient<IRequestHandler<EnableLdapAccountCommand, Result>, EnableLdapAccountHandler>();

        services.AddTransient<IRequestHandler<DisableLdapAccountCommand, Result>, DisableLdapAccountHandler>();

​

        var provider = services.BuildServiceProvider();

​

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

​

        var correlationId = Guid.NewGuid().ToString();

        List<IWorkflowCommand> steps = new List<IWorkflowCommand>();

        steps.Add(new EnableLdapAccountCommand

        {

            SAMAccountName = "EnableMe",

            CorrelationId = correlationId,

        });     

        steps.Add(new DisableLdapAccountCommand

        {

            SAMAccountName = "DisableMe",

            CorrelationId = correlationId,

        });     

​

        var results = new List<IResult>();

        foreach (var step in steps)

        {

            var response = await mediator.Send(step);

            results.Add((IResult)response);

        }

​

        results.Dump();

    }

}

​

public interface IWorkflowCommand

{

    public string CorrelationId { get; set; }

}

​

public class DisableLdapAccountCommand : IRequest<Result>, IWorkflowCommand

{

    public string SAMAccountName { get; set; }

​

    public string CorrelationId { get; set; }

}

​

public class EnableLdapAccountCommand : IRequest<Result>, IWorkflowCommand

{

    public string SAMAccountName { get; set; }

​

    public string CorrelationId { get; set; }

}

​

public class EnableLdapAccountHandler : IRequestHandler<EnableLdapAccountCommand, Result>

{

    public Task<Result> Handle(EnableLdapAccountCommand request, CancellationToken cancellationToken)

    {

        throw new Exception("EnableLdapAccountCommand Exception");

    }

}

​

public class DisableLdapAccountHandler : IRequestHandler<DisableLdapAccountCommand, Result>

{

    public Task<Result> Handle(DisableLdapAccountCommand request, CancellationToken cancellationToken)

    {

        return Task.FromResult(Result.Success());

    }

}

​

public class StepRecorderingRequestPostProcessor<TRequest, TResponse> : IRequestPostProcessor<TRequest, TResponse>

    where TRequest : IWorkflowCommand

    where TResponse : Result

{

    public Task Process(TRequest request, TResponse response, CancellationToken cancellationToken)

    {

        $"Post-2-Ran: ({request.GetType().Name}) {response.Status}".Dump();

        return Task.CompletedTask;

    }

}

​

public class GenericRequestExceptionHandler2<TRequest, TResponse, TException> : IRequestExceptionHandler<TRequest, Result, TException>

    where TRequest : IWorkflowCommand

    where TException : Exception

{

    public Task Handle(

        TRequest request,

        TException exception,

        RequestExceptionHandlerState<Result> state,

        CancellationToken cancellationToken = new CancellationToken())

    {

        Console.WriteLine("GenericRequestExceptionHandler2 translating exception to error.");

        var translatedResponse = Result.Error("Unhandled exception.");

        //  yes Ownix if TResponse is anything but Result it will bomb

        state.SetHandled(translatedResponse);

        return Task.CompletedTask;

    }

}

​