IPipeLineBehavior, MediatR - przerwanie PreProcessora

Witajcie. Czy ktoś korzysta z IPipeLine (mediatR) w swoich aplikacjach?. Mam zagwozdkę. Powiedzmy, że mam handlera dodającego coś do bazy. I chciałbym przed wywołaniem handlera wywołać Ipreprocessor który sprawdzi mi np czy istnieje coś w bazie. Czyli tak: mediator.send(command) -> walidacja -> preprocesory ->handler.

RequestValidationBehavior działa bez zarzutu.

public class RequestValidationBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
       where TRequest : IRequest<TResponse> where TResponse : class
    {
        private readonly IEnumerable<IValidator<TRequest>> _validators;

        public RequestValidationBehavior(IEnumerable<IValidator<TRequest>> validators)
        {
            _validators = validators;
        }

        public Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
        {
            var context = new ValidationContext(request);

            var failures = _validators
                .Select(v => v.Validate(context))
                .SelectMany(result => result.Errors)
                .Where(f => f != null)
                .ToList();
            
            return failures.Any()
                ? Errors(failures)
                : next();
        }

        private static Task<TResponse> Errors(IEnumerable<ValidationFailure> failures)
        {
            var response = new Response();

            foreach (var failure in failures)
            {
                response.AddError(failure.PropertyName + " " + failure.ErrorMessage.ToLower());
            }

            return Task.FromResult(response as TResponse);
        }
    }

Potem wchodzą preprocesory

public class RequestPreProcessorBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
        where TRequest : IRequest<TResponse> where TResponse : class
    {
        private readonly IEnumerable<IRequestPreProcessor<TRequest>> _preProcessors;
        public RequestPreProcessorBehavior(IEnumerable<IRequestPreProcessor<TRequest>> preProcessors)
        {
            _preProcessors = preProcessors;
        }
        public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
        {
            foreach (var processor in _preProcessors)
            {
                var result = processor.Process(request, cancellationToken);               

            }

            return await next().ConfigureAwait(false);
        }
    }

I tu mam problem bo interfejs IRequestPreProcessor<TRequest> nie zwraca nic z metody tzn zwr Task zamiast Task<TResponse> . A w zależności od powodzenia chciałbym przerwać pętle lub kontynuować.
IRequestPreProcessor to jest z mediatR.

Czy ktoś próbował coś takiego? Jak to zrealizować w miarę ładnie?.
Czyli jeśli PreProcessor zwróci błąd to przerywał cały pipeLine

Problem rozwiązany. W miejsce IRequestPreProcessor<TRequest> podstawiłem swój interfejs

public interface ICheckRequest<TRequest, TResponse> where TRequest : IRequest<TResponse> where TResponse : Response
    {
        Task<TResponse> CheckRequest(TRequest request, CancellationToken cancellationToken);
    }

i zarejestrowałem wszystkie klasy, które go implementują i działa dobrze.