Code accompanying blog post.

Registration of AbstractValidator<> with StructureMap

ObjectFactory.Initialize(x =>
{
    x.Scan(scan =>
    {
        scan.TheCallingAssembly();
        scan.WithDefaultConventions();
        scan.ConnectImplementationsToTypesClosing(typeof(AbstractValidator<>));
    });
});

Fluent Validation Action Filter

public sealed class ValidationActionFilter : ActionFilterAttribute
    {
        public override void OnActionExecuting(HttpActionContext actionContext)
        {
            var actionArgument = GetTheActionArgument(actionContext);
            if (actionArgument == null) return;
 
            var validator = GetValidatorForActionArgument(actionArgument);
            if (validator == null) return;
 
            var validationResult = validator.Validate(actionArgument);
 
            if (validationResult.IsValid) return;
 
            CreateBadRequestResponse(validationResult);
        }
 
        private static IValidator GetValidatorForActionArgument(object actionArgument)
        {
            var validatorFactory = new StructureMapValidatorFactory();
            return validatorFactory.GetValidator(actionArgument.GetType());
        }
 
        private static object GetTheActionArgument(HttpActionContext actionContext)
        {
            return actionContext.ActionArguments.SingleOrDefault().Value;
        }
 
        private static void CreateBadRequestResponse(ValidationResult validationResult)
        {
            var validationErrors =
               validationResult.Errors.Select(e => new KeyValuePair<string, string>(e.PropertyName, e.ErrorMessage));
 
            throw new HttpBadRequestResponseException(JsonConvert.SerializeObject(validationErrors));
        }
    }

HttpBadRequestResponseException

public sealed class HttpBadRequestResponseException : HttpResponseException
{
    public HttpBadRequestResponseException()
        : this(string.Empty)
    {
    }

    public HttpBadRequestResponseException(string message)
        : base(new HttpResponseMessage(HttpStatusCode.BadRequest) { Content = new StringContent(message) })
    {
    }
}

Validator Example

public class StudentInputValidator : AbstractValidator<StudentUpdateModel>
    {
        public StudentInputValidator()
        {
            RuleFor(s => s.Id).NotEmpty();
 
            RuleFor(s => s.Balance)
                .NotEmpty()
                .GreaterThan(0);
        }
    }

Validator Factory

    public class StructureMapValidatorFactory : IValidatorFactory
    {
        private readonly InstanceCache _cache = new InstanceCache();

        public IValidator<T> GetValidator<T>()
        {
            throw new NotSupportedException("Generic implementation is not supported");
        }

        public IValidator GetValidator(Type type)
        {
            if (type == null) return null;

            var abstractValidatorType = typeof (AbstractValidator<>);
            var validatorForType = abstractValidatorType.MakeGenericType(type);

            var validator = ObjectFactory.TryGetInstance(validatorForType);

            return validator != null ? _cache.GetOrCreateInstance(validator.GetType()) as IValidator : null;
        }
    }