[HttpPost]

public ActionResult Add(Person instance)

{

    if (!this.ModelState.IsValid)

    {

        // return the same view with validation errors

        return View(instance);

    }

    // save the new person instance and go back to master view

    Person result = this.Service.Add(instance);

    return RedirectToAction("Index");

}

[HttpPost]

public ActionResult Add(Person instance)

{

    if (!this.ModelState.IsValid)

    {

        // we'll see this in a bit

    }

    // save the new person instance and go back to master view

    Person result = this.Service.Add(instance);

    return PartialView("Person", result); // or Json(result)

}

$.ajax({

    url: "Person/Add",

    type: "POST",

    data: $(this).serializeArray(), // provided this code executes in form.onsubmit event

    success: function(data, status, xhr) {

        // YAY! Process data

    },

    error: function(xhr, status, err) {

        if (xhr.status == 400)

        {

            // this is our erroneous result

        }

        else

        {

            // some other server error must have happened (most probably HTTP 5xx)

        }

    }

});

/// <summary>

/// This exception that is thrown when there are model state errors.

/// </summary>

[Serializable]

public class ModelStateException : Exception

{

    /// <summary>

    /// Gets the model errors.

    /// </summary>

    public Dictionary<string, string> Errors { get; private set; }

    /// <summary>

    /// Gets a message that describes the current exception and is related to the first model state error.

    /// </summary>

    /// <value></value>

    public override string Message

    {

        get

        {

            if (this.Errors.Count > 0)

            {

                return this.Errors.First().Value;

            }

            return null;

        }

    }

    /// <summary>

    /// Initializes a new instance of the <see cref="ModelStateException"/> class.

    /// </summary>

    public ModelStateException() : base()

    {

        this.Errors = new Dictionary<string, string>();

    }

    /// <summary>

    /// Initializes a new instance of the <see cref="ModelStateException"/> class.

    /// </summary>

    /// <param name="modelState">State of the model.</param>

    public ModelStateException(ModelStateDictionary modelState)

        : this()

    {

        if (modelState == null)

        {

            throw new ArgumentNullException("modelState");

        }

        //this.ModelState = modelState;

        if (!modelState.IsValid)

        {

            StringBuilder errors;

            foreach (KeyValuePair<string, ModelState> state in modelState)

            {

                if (state.Value.Errors.Count > 0)

                {

                    errors = new StringBuilder();

                    foreach (ModelError err in state.Value.Errors)

                    {

                        errors.AppendLine(err.ErrorMessage);

                    }

                    this.Errors.Add(state.Key, errors.ToString());

                }

            }

        }

    }

    /// <summary>

    /// Initializes a new instance of the <see cref="ModelStateException"/> class.

    /// </summary>

    /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>

    /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>

    /// <exception cref="T:System.ArgumentNullException">

    /// The <paramref name="info"/> parameter is null.

    /// </exception>

    /// <exception cref="T:System.Runtime.Serialization.SerializationException">

    /// The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).

    /// </exception>

    protected ModelStateException(SerializationInfo info, StreamingContext context)

        : base(info, context)

    {

        if (info == null)

        {

            throw new ArgumentNullException("info");

        }

        // deserialize

        this.Errors = info.GetValue("ModelStateException.Errors", typeof(Dictionary<string, string>)) as Dictionary<string, string>;

    }

    /// <summary>

    /// Initializes a new instance of the <see cref="ModelStateException"/> class.

    /// </summary>

    /// <param name="message">The message.</param>

    public ModelStateException(string message)

        : base(message)

    {

        this.Errors = new Dictionary<string, string>();

        this.Errors.Add(string.Empty, message);

    }

    /// <summary>

    /// Initializes a new instance of the <see cref="ModelStateException"/> class.

    /// </summary>

    /// <param name="message">The message.</param>

    /// <param name="innerException">The inner exception.</param>

    public ModelStateException(string message, Exception innerException)

        : base(message, innerException)

    {

        this.Errors = new Dictionary<string, string>();

        this.Errors.Add(string.Empty, message);

    }

    /// <summary>

    /// When overridden in a derived class, sets the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> with information about the exception.

    /// </summary>

    /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>

    /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>

    /// <exception cref="T:System.ArgumentNullException">

    /// The <paramref name="info"/> parameter is a null reference (Nothing in Visual Basic).

    /// </exception>

    /// <PermissionSet>

    ///     <IPermission class="System.Security.Permissions.FileIOPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Read="*AllFiles*" PathDiscovery="*AllFiles*"/>

    ///     <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="SerializationFormatter"/>

    /// </PermissionSet>

    [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]

    public override void GetObjectData(SerializationInfo info, StreamingContext context)

    {

        if (info == null)

        {

            throw new ArgumentNullException("info");

        }

        // serialize errors

        info.AddValue("ModelStateException.Errors", this.Errors, typeof(Dictionary<string, string>));

        base.GetObjectData(info, context);

    }

}

/// <summary>

/// Represents errors that occur due to invalid application model state.

/// </summary>

[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, AllowMultiple = false)]

public sealed class HandleModelStateExceptionAttribute : FilterAttribute, IExceptionFilter

{

    /// <summary>

    /// Called when an exception occurs and processes <see cref="ModelStateException"/> object.

    /// </summary>

    /// <param name="filterContext">Filter context.</param>

    public void OnException(ExceptionContext filterContext)

    {

        if (filterContext == null)

        {

            throw new ArgumentNullException("filterContext");

        }

        // handle modelStateException

        if (filterContext.Exception != null && typeof(ModelStateException).IsInstanceOfType(filterContext.Exception) && !filterContext.ExceptionHandled)

        {

            filterContext.ExceptionHandled = true;

            filterContext.HttpContext.Response.Clear();

            filterContext.HttpContext.Response.ContentEncoding = Encoding.UTF8;

            filterContext.HttpContext.Response.HeaderEncoding = Encoding.UTF8;

            filterContext.HttpContext.Response.TrySkipIisCustomErrors = true;

            filterContext.HttpContext.Response.StatusCode = 400;

            filterContext.Result = new ContentResult {

                Content = (filterContext.Exception as ModelStateException).Message,

                ContentEncoding = Encoding.UTF8,

            };

        }

    }

}

[HttpPost]

[HandleModelStateException]

public ActionResult Add(Person instance)

{

    if (!this.ModelState.IsValid)

    {

        throw new ModelStateException(this.ModelState);

    }

    // save the new person instance and go back to master view

    Person result = this.Service.Add(instance);

    return PartialView("Person", result);

}

$.extend({

    appAjax: function(url, type, datagetter, onsuccess) {

        /// <summary>jQuery extension that executes Ajax calls and handles errors in application specific ways.</summary>

        /// <param name="url" type="String">URL address where to issue this Ajax call.</param>

        /// <param name="type" type="String">HTTP method type (GET, POST, DELETE, PUT, HEAD)</param>

        /// <param name="datagetter" type="Function">This parameterless function will be called to return ajax data.</param>

        /// <param name="onsuccess" type="Function">This optional function(data) will be called after a successful Ajax call.</param>

        var execSuccess = $.isFunction(onsuccess) ? onsuccess : $.noop;

        var getData = $.isFunction(datagetter) ? datagetter : function() { return datagetter; };

        $.ajax({

            url: url,

            type: type,

            data: getData(),

            error: function(xhr, status, err) {

                if (xhr.status == 400)

                {

                    alert(xhr.responseText);

                }

                else

                {

                    alert("Server error has occured.");

                }

            },

            success: function(data, status, xhr) {

                window.setTimeout(function() {

                    execSuccess(data);

                }, 10);

            }

        });

    }

});

$.appAjax(

    "Person/Add",

    "POST",

    function() { return $(this).serializeArray(); },

    function(data) { // consume data }

);