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 =>

    {

        // Doesnt do anything in LinqPad I think

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

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

        cfg.AddOpenBehavior(typeof(KeepGoinRequestExceptionProcessorBehavior<,>));

    });

​

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

​

    var provider = services.BuildServiceProvider();

​

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

​

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

​

    var response = await mediator.Send(new DisableLdapAccountCommand

    {

        SAMAccountName = "MyUser",

        CorrelationId = correlationId,

    });

    response.Dump();

    }

}

​

public class KeepGoinRequestExceptionProcessorBehavior<TRequest, TResponse> : RequestExceptionProcessorBehavior<TRequest, TResponse>

{

    public KeepGoinRequestExceptionProcessorBehavior(IServiceProvider serviceProvider)

        : base(serviceProvider)

    {

    }

​

    public async Task<TResponse> HandleAsync(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)

    {

        throw new Exception("Here we go");

    }

}

​

public abstract class WorkflowCommand

{

    public string CorrelationId { get; set; }

    // Todo: Auditing stuff

}

​

public class DisableLdapAccountCommand : WorkflowCommand, IRequest<Result>

{

    public string SAMAccountName { get; set; }

}

​

public class DisableLdapAccountHandler : IRequestHandler<DisableLdapAccountCommand, Result>

{

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

    {

        var ldapService = new LdapService();

        // ! This throws !

        ldapService.DisableLocalAccount(request.SAMAccountName);

        return Task.FromResult(Result.SuccessWithMessage("DisableLdapAccountHandler Should Not Have Worked"));

    }

}

​

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

    where TRequest : WorkflowCommand

    where TResponse : Result

{

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

    {

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

        //throw new NotImplementedException($"Post: {request.CorrelationId}");

        return Task.CompletedTask;

    }

}

​

public class GenericRequestExceptionHandler<TRequest, TResponse, TException> : IRequestExceptionHandler<WorkflowCommand, Result, TException>

    where TException : Exception

{

    public Task Handle(

        WorkflowCommand request,

        TException exception,

        RequestExceptionHandlerState<Result> state,

        CancellationToken cancellationToken = new CancellationToken())

    {

        $"GenericRequestExceptionHandler translating exception to error ({request.GetType().Name}).".Dump();

        var translatedResponse = Result.Error("GenericRequestExceptionHandler handled this.");

        // Also I noticed Post handlers will not run after this

        state.SetHandled(translatedResponse);

        return Task.CompletedTask;

    }

}

​

public class LdapService

{

    public void DisableLocalAccount(string SAMAccountName)

    {

        throw new Exception("Disable LDAP Account Error");

    }

}