Integrating Fluent Validation in Web API using Autofac

Create New Project

Install Necessary Packages

  Install-Package Autofac
  Install-Package Autofac.WebApi2
  Install-Package FluentValidation
  Install-Package FluentValidation.WebApi
  Install-Package Microsoft.AspNet.WebApi
  Install-Package Microsoft.AspNet.WebApi.Owin
  Install-Package Microsoft.Owin.Host.SystemWeb
  Install-Package Owin
  Install-Package Newtonsoft.Json
 

Create Partial Startup Classes

Partial class is just splitting class file into two or more files, and all parts are combined when the application is compiled.

It is used in a situation

• When working on large projects, spreading a class over separate files enables multiple programmers to work on it at the same time.
• When working with automatically generated source, code can be added to the class without having to recreate the source file. Visual Studio uses this approach when it creates Windows Forms, Web service wrapper code, and so on. You can create code that uses these classes without having to modify the file created by Visual Studio.
• To split a class definition, use the partial keyword modifier

While adding this class our project structure looks like.

Startup.Autofac.cs

	using Autofac;
	using Autofac.Features.ResolveAnything;
	using System;
	using System.Collections.Generic;
	using System.Linq;
	using System.Web;
	namespace FluentAutofacValidationAPI.App_Start
	{
	public partial class Startup
	{
	private static IContainer ConfigureAutofac()
	{
	var builder = new ContainerBuilder();
	builder.RegisterModule<AutofacWebModule>();
	builder.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource());
	var container = builder.Build();
	return container;
	}
	}
	}

view raw Startup.Autofac.cs hosted with ❤ by GitHub

Startup.WebApi.cs

	using Autofac;
	using Autofac.Features.ResolveAnything;
	using System;
	using System.Collections.Generic;
	using System.Linq;
	using System.Web;
	namespace FluentAutofacValidationAPI
	{
	public partial class Startup
	{
	private static IContainer ConfigureAutofac()
	{
	var builder = new ContainerBuilder();
	builder.RegisterModule<AutofacWebModule>();
	builder.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource());
	var container = builder.Build();
	return container;
	}
	}
	}

view raw Startup.WebApi.cs hosted with ❤ by GitHub

Startup.cs

	using Autofac;
	using Autofac.Features.ResolveAnything;
	using System;
	using System.Collections.Generic;
	using System.Linq;
	using System.Web;
	namespace FluentAutofacValidationAPI
	{
	public partial class Startup
	{
	private static IContainer ConfigureAutofac()
	{
	var builder = new ContainerBuilder();
	builder.RegisterModule<AutofacWebModule>();
	builder.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource());
	var container = builder.Build();
	return container;
	}
	}
	}

view raw Startup.cs hosted with ❤ by GitHub

Add Infrastructure classes

Now our Project structure looks like

AutofacValidatorFactory.cs

	using Autofac;
	using FluentValidation;
	using System;
	using System.Collections.Generic;
	using System.Linq;
	using System.Web;
	namespace FluentAutofacValidationAPI.Infrastructure
	{
	public class AutofacValidatorFactory : ValidatorFactoryBase
	{
	private readonly IComponentContext _context;
	public AutofacValidatorFactory(IComponentContext context)
	{
	_context = context;
	}
	public override IValidator CreateInstance(Type validatorType)
	{
	object instance;
	if (_context.TryResolve(validatorType, out instance))
	{
	var validator = instance as IValidator;
	return validator;
	}
	return null;
	}
	}
	}

view raw AutofacValidatorFactory.cs hosted with ❤ by GitHub

AutofacWebModule.cs

	using Autofac;
	using Autofac.Integration.WebApi;
	using FluentValidation;
	using FluentValidation.WebApi;
	using System;
	using System.Collections.Generic;
	using System.Linq;
	using System.Web;
	using System.Web.Http.Validation;
	namespace FluentAutofacValidationAPI.Infrastructure
	{
	public class AutofacWebModule : Module
	{
	protected override void Load(ContainerBuilder builder)
	{
	builder.RegisterApiControllers(ThisAssembly);
	builder.RegisterAssemblyTypes(ThisAssembly)
	.Where(t => t.Name.EndsWith("Validator"))
	.AsImplementedInterfaces()
	.InstancePerLifetimeScope();
	builder.RegisterType<FluentValidationModelValidatorProvider>().As<ModelValidatorProvider>();
	builder.RegisterType<AutofacValidatorFactory>().As<IValidatorFactory>().SingleInstance();
	base.Load(builder);
	}
	}
	}

view raw AutofacWebModule.cs hosted with ❤ by GitHub

ValidateFilterAttribute.cs

	using System.Linq;
	using System.Net;
	using System.Net.Http;
	using System.Web.Http.Controllers;
	using System.Web.Http.Filters;
	namespace FluentAutofacValidationAPI.Infrastructure
	{
	public class ValidateFilterAttribute : ActionFilterAttribute
	{
	public override void OnActionExecuting(HttpActionContext actionContext)
	{
	if (!actionContext.ModelState.IsValid)
	{
	actionContext.Response =
	actionContext.Request.CreateErrorResponse(HttpStatusCode.BadRequest, actionContext.ModelState);
	}
	else if (actionContext.ActionArguments.FirstOrDefault().Value == null)
	{
	actionContext.ModelState.AddModelError("Model Null", "Form is empty. Please enter some value");
	actionContext.Response =
	actionContext.Request.CreateErrorResponse(HttpStatusCode.BadRequest, actionContext.ModelState);
	}
	base.OnActionExecuting(actionContext);
	}
	}
	}

view raw ValidateFilterAttribute.cs hosted with ❤ by GitHub

Add Modal Validation and Controller

Now our Project structure looks like

Controller

	using FluentAutofacValidationAPI.Infrastructure;
	using FluentAutofacValidationAPI.Models;
	using System.Web.Http;
	namespace FluentAutofacValidationAPI.Controllers
	{
	[RoutePrefix("api/people")]
	public class PeopleController : ApiController
	{
	[HttpPost]
	[Route("create")]
	[ValidateFilter]
	public IHttpActionResult CreatePerson(Person person)
	{
	return Ok("ok");
	}
	}
	}

view raw PeopleController.cs hosted with ❤ by GitHub

Model and Model Validation

	using FluentValidation;
	namespace FluentAutofacValidationAPI.Models
	{
	public class PersonValidator : AbstractValidator<Person>
	{
	public PersonValidator()
	{
	RuleFor(x => x.FirstName).NotEmpty();
	RuleFor(x => x.LastName).NotEmpty();
	}
	}
	public class Person
	{
	public string FirstName { get; set; }
	public string OtherNames { get; set; }
	public string LastName { get; set; }
	}
	}

view raw Person.cs hosted with ❤ by GitHub

Finally test our code

Thanks,


Download Code