Return response with errors instead of throwing exception in validation pipeline mediatr 3

Simply don't call next if there's any failures:

public Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next)
{
    var failures = _validators
        .Select(v => v.Validate(request))
        .SelectMany(result => result.Errors)
        .Where(f => f != null)
        .ToList();

    if (failures.Any())
    {
        var response = new Thing(); //obviously a type conforming to TResponse
        response.Failures = failures; //I'm making an assumption on the property name here.

        return Task.FromResult(response);
    }
    else
    {
        return next();
    }
}

Note:
Your class (Thing in my example) must be of type TResponse

Several years ago, I created general Result object, which I constanly improving. It is quite simple, check https://github.com/martinbrabec/mbtools.

If you will be ok that the Result (or Result<>) is the return type every method in Application layer, then you can use the ValidationBehavior like this:

public class ValidationBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
    where TRequest : IRequest<TResponse>
    where TResponse : Result, new()
{
    private readonly IEnumerable<IValidator<TRequest>> _validators;

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

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

            List<ValidationFailure> failures = _validators
                .Select(v => v.Validate(context))
                .SelectMany(result => result.Errors)
                .Where(f => f != null)
                .ToList();

            if (failures.Any())
            {
                TResponse response = new TResponse();

                response.Set(ErrorType.NotValid, failures.Select(s => s.ErrorMessage), null);

                return Task.FromResult<TResponse>(response);
            }
            else
            {
                return next();
            }
        }

        return next();
    }

}

Since all your handlers return Result (or Result<>, which is based uppon Result), you will be able to handle all validation errors without any exception.