Desativar o atributo de validação necessário em determinadas circunstâncias

Eu queria saber se é possível desativar o atributo de validação necessária em determinadas ações do controlador. Estou pensando isso, porque em um dos meus formulários de edição não exijo que o usuário insira valores para os campos que eles já especificaram anteriormente. No entanto, implemento a lógica de que, quando eles inserem um valor, ela usa alguma lógica especial para atualizar o modelo, como hash de um valor etc.

Alguma sugestão de como contornar esse problema?

EDIT:
E sim, a validação do cliente é um problema aqui, pois não permitirá que eles enviem o formulário sem inserir um valor.

Esse problema pode ser facilmente resolvido usando os modelos de exibição. Os modelos de exibição são classes especificamente adaptadas às necessidades de uma determinada exibição. Por exemplo, no seu caso, você pode ter os seguintes modelos de exibição:

public UpdateViewView
{
    [Required]
    public string Id { get; set; }

    ... some other properties
}

public class InsertViewModel
{
    public string Id { get; set; }

    ... some other properties
}

que será usado em suas ações correspondentes do controlador:

[HttpPost]
public ActionResult Update(UpdateViewView model)
{
    ...
}

[HttpPost]
public ActionResult Insert(InsertViewModel model)
{
    ...
}

Se você quiser apenas desativar a validação para um único campo no lado do cliente, poderá substituir os atributos de validação da seguinte maneira:

@Html.TexBoxFor(model => model.SomeValue, 
                new Dictionary<string, object> { { "data-val", false }})

Eu sei que esta pergunta foi respondida há muito tempo e a resposta aceita realmente fará o trabalho. Mas há uma coisa que me incomoda: ter que copiar dois modelos apenas para desativar uma validação.

Aqui está a minha sugestão:

public class InsertModel
{
    [Display(...)]
    public virtual string ID { get; set; }

    ...Other properties
}

public class UpdateModel : InsertModel
{
    [Required]
    public override string ID
    {
        get { return base.ID; }
        set { base.ID = value; }
    }
}

Dessa forma, você não precisa se preocupar com as validações do lado do cliente / servidor, a estrutura se comportará da maneira que deveria. Além disso, se você definir um [Display]atributo na classe base, não precisará redefini-lo no seu UpdateModel.

E você ainda pode usar essas classes da mesma maneira:

[HttpPost]
public ActionResult Update(UpdateModel model)
{
    ...
}

[HttpPost]
public ActionResult Insert(InsertModel model)
{
    ...
}

Você pode remover toda a validação de uma propriedade com o seguinte na ação do seu controlador.

ModelState.Remove<ViewModel>(x => x.SomeProperty);

@ Comentário de Ian sobre MVC5

Ainda é possível o seguinte

ModelState.Remove("PropertyNameInModel");

É irritante que você perca a digitação estática com a API atualizada. Você pode conseguir algo semelhante à maneira antiga, criando uma instância do auxiliar HTML e usando os métodos NameExtensions .

Lado do cliente Para desativar a validação de um formulário, várias opções baseadas em minha pesquisa são fornecidas abaixo. Espero que um deles funcione para você.

Opção 1

Eu prefiro isso, e isso funciona perfeitamente para mim.

(function ($) {
    $.fn.turnOffValidation = function (form) {
        var settings = form.validate().settings;

        for (var ruleIndex in settings.rules) {
            delete settings.rules[ruleIndex];
        }
    };
})(jQuery); 

e invocando como

$('#btn').click(function () {
    $(this).turnOffValidation(jQuery('#myForm'));
});

opção 2

$('your selector here').data('val', false);
$("form").removeData("validator");
$("form").removeData("unobtrusiveValidation");
$.validator.unobtrusive.parse("form");

Opção 3

var settings = $.data($('#myForm').get(0), 'validator').settings;
settings.ignore = ".input";

Opção 4

 $("form").get(0).submit();
 jQuery('#createForm').unbind('submit').submit();

Opção 5

$('input selector').each(function () {
    $(this).rules('remove');
});

Lado do servidor

Crie um atributo e marque seu método de ação com esse atributo. Personalize isso para se adaptar às suas necessidades específicas.

[AttributeUsage(AttributeTargets.All)]
public class IgnoreValidationAttribute : ActionFilterAttribute
{
    public override void OnActionExecuting(ActionExecutingContext filterContext)
    {
        var modelState = filterContext.Controller.ViewData.ModelState;

        foreach (var modelValue in modelState.Values)
        {
            modelValue.Errors.Clear();
        }
    }
}

Uma abordagem melhor foi descrita aqui Ativar / Desativar validação do lado do servidor mvc dinamicamente

Pessoalmente, eu tenderia a usar a abordagem que Darin Dimitrov mostrou em sua solução. Isso libera você para poder usar a abordagem de anotação de dados com validação E ter atributos de dados separados em cada ViewModel correspondente à tarefa em questão. Para minimizar a quantidade de trabalho para copiar entre o modelo e o viewmodel, consulte o AutoMapper ou o ValueInjecter . Ambos têm seus pontos fortes individuais, então verifique os dois.

Outra abordagem possível para você seria derivar seu viewmodel ou modelo de IValidatableObject. Isso fornece a opção de implementar uma função Validar. Na validação, você pode retornar uma lista de elementos ValidationResult ou emitir um retorno de rendimento para cada problema detectado na validação.

O ValidationResult consiste em uma mensagem de erro e uma lista de cadeias com os nomes de campo. As mensagens de erro serão mostradas em um local próximo ao (s) campo (s) de entrada.

public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
{
  if( NumberField < 0 )
  {
    yield return new ValidationResult( 
        "Don't input a negative number", 
        new[] { "NumberField" } );
  }

  if( NumberField > 100 )
  {
    yield return new ValidationResult( 
        "Don't input a number > 100", 
        new[] { "NumberField" } );
  }

  yield break;
}

A maneira mais limpa aqui, acredito, será desabilitar a validação do lado do cliente e, no lado do servidor, você precisará:

1. ModelState ["SomeField"]. Errors.Clear (no seu controlador ou crie um filtro de ação para remover erros antes que o código do controlador seja executado)
2. Adicione ModelState.AddModelError do código do seu controlador quando detectar uma violação dos problemas detectados.

Parece que mesmo um modelo de visualização personalizado aqui não resolve o problema porque o número desses campos 'pré-respondidos' pode variar. Se não o fizerem, um modelo de visualização personalizado pode ser a maneira mais fácil, mas usando a técnica acima, você poderá solucionar seus problemas de validação.

essa foi a resposta de outra pessoa nos comentários ... mas deve ser uma resposta real:

$("#SomeValue").removeAttr("data-val-required")

testado no MVC 6 com um campo com o [Required]atributo

resposta roubada de https://stackoverflow.com/users/73382/rob acima

Eu estava com esse problema ao criar uma visualização de edição para o meu modelo e quero atualizar apenas um campo.

Minha solução para uma maneira mais simples é colocar os dois campos usando:

 <%: Html.HiddenFor(model => model.ID) %>
 <%: Html.HiddenFor(model => model.Name)%>
 <%: Html.HiddenFor(model => model.Content)%>
 <%: Html.TextAreaFor(model => model.Comments)%>

Comentários é o campo que eu atualizo apenas na Visualização de Edição, que não possui Atributo Requerido.

Entidade do ASP.NET MVC 3

AFAIK, você não pode remover o atributo em tempo de execução, mas apenas alterar seus valores (ou seja: readonly true / false) procure aqui algo semelhante . Como outra maneira de fazer o que você deseja, sem mexer nos atributos, irei com um ViewModel para sua ação específica, para que você possa inserir toda a lógica sem interromper a lógica necessária para outros controladores. Se você tentar obter algum tipo de assistente (um formulário de várias etapas), poderá serializar os campos já compilados e, com o TempData, acompanhá-los nas etapas. (para obter ajuda na serialização de desserialização, você pode usar futuros do MVC )

O que @Darin disse é o que eu recomendaria também. No entanto, eu acrescentaria a ele (e em resposta a um dos comentários) que você também pode usar esse método para tipos primitivos como bit, bool e até estruturas como Guid, simplesmente tornando-os anuláveis. Depois de fazer isso, o Requiredatributo funcionará conforme o esperado.

public UpdateViewView
{
    [Required]
    public Guid? Id { get; set; }
    [Required]
    public string Name { get; set; }
    [Required]
    public int? Age { get; set; }
    [Required]
    public bool? IsApproved { get; set; }
    //... some other properties
}

A partir do MVC 5, isso pode ser facilmente alcançado adicionando-o ao seu global.asax.

DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes = false;

Eu estava procurando uma solução em que eu possa usar o mesmo modelo para inserir e atualizar na API da Web. Na minha situação, isso é sempre um conteúdo corporal. Os [Requiered]atributos devem ser ignorados se for um método de atualização. Na minha solução, você coloca um atributo [IgnoreRequiredValidations]acima do método. É o seguinte:

public class WebServiceController : ApiController
{
    [HttpPost]
    public IHttpActionResult Insert(SameModel model)
    {
        ...
    }

    [HttpPut]
    [IgnoreRequiredValidations]
    public IHttpActionResult Update(SameModel model)
    {
        ...
    }

    ...

O que mais precisa ser feito? Um próprio BodyModelValidator deve ser criado e adicionado na inicialização. Isso está no HttpConfiguration e fica assim:config.Services.Replace(typeof(IBodyModelValidator), new IgnoreRequiredOrDefaultBodyModelValidator());

using Owin;
using your_namespace.Web.Http.Validation;

[assembly: OwinStartup(typeof(your_namespace.Startup))]

namespace your_namespace
{
    public class Startup
    {
        public void Configuration(IAppBuilder app)
        {
            Configuration(app, new HttpConfiguration());
        }

        public void Configuration(IAppBuilder app, HttpConfiguration config)
        {
            config.Services.Replace(typeof(IBodyModelValidator), new IgnoreRequiredOrDefaultBodyModelValidator());
        }

        ...

Meu próprio BodyModelValidator é derivado do DefaultBodyModelValidator. E eu descobri que tive que substituir o método 'ShallowValidate'. Nesta substituição, filtrei os validadores de modelo exigidos. E agora a classe IgnoreRequiredOrDefaultBodyModelValidator e a classe de atributo IgnoreRequiredValidations:

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.Validation;

namespace your_namespace.Web.Http.Validation
{
    public class IgnoreRequiredOrDefaultBodyModelValidator : DefaultBodyModelValidator
    {
        private static ConcurrentDictionary<HttpActionBinding, bool> _ignoreRequiredValidationByActionBindingCache;

        static IgnoreRequiredOrDefaultBodyModelValidator()
        {
            _ignoreRequiredValidationByActionBindingCache = new ConcurrentDictionary<HttpActionBinding, bool>();
        }

        protected override bool ShallowValidate(ModelMetadata metadata, BodyModelValidatorContext validationContext, object container, IEnumerable<ModelValidator> validators)
        {
            var actionContext = validationContext.ActionContext;

            if (RequiredValidationsIsIgnored(actionContext.ActionDescriptor.ActionBinding))
                validators = validators.Where(v => !v.IsRequired);          

            return base.ShallowValidate(metadata, validationContext, container, validators);
        }

        #region RequiredValidationsIsIgnored
        private bool RequiredValidationsIsIgnored(HttpActionBinding actionBinding)
        {
            bool ignore;

            if (!_ignoreRequiredValidationByActionBindingCache.TryGetValue(actionBinding, out ignore))
                _ignoreRequiredValidationByActionBindingCache.TryAdd(actionBinding, ignore = RequiredValidationsIsIgnored(actionBinding.ActionDescriptor as ReflectedHttpActionDescriptor));

            return ignore;
        }

        private bool RequiredValidationsIsIgnored(ReflectedHttpActionDescriptor actionDescriptor)
        {
            if (actionDescriptor == null)
                return false;

            return actionDescriptor.MethodInfo.GetCustomAttribute<IgnoreRequiredValidationsAttribute>(false) != null;
        } 
        #endregion
    }

    [AttributeUsage(AttributeTargets.Method, Inherited = true)]
    public class IgnoreRequiredValidationsAttribute : Attribute
    {

    }
}

Fontes:

• Usando string debug = new StackTrace().ToString()para descobrir quem está lidando com a validação do modelo.
• https://docs.microsoft.com/pt-br/aspnet/web-api/overview/advanced/configuring-aspnet-web-api para saber como definir meu próprio validador.
• https://github.com/ASP-NET-MVC/aspnetwebstack/blob/master/src/System.Web.Http/Validation/DefaultBodyModelValidator.cs para descobrir o que esse validador está fazendo.
• https://github.com/Microsoft/referencesource/blob/master/System.Web/ModelBinding/DataAnnotationsModelValidator.cs para descobrir por que a propriedade IsRequired está definida como true. Aqui você também pode encontrar o atributo original como uma propriedade.

Se você não quiser usar outro ViewModel, poderá desativar as validações do cliente na exibição e também remover as validações no servidor para as propriedades que deseja ignorar. Verifique esta resposta para obter uma explicação mais profunda https://stackoverflow.com/a/15248790/1128216

No meu caso, o mesmo modelo foi usado em muitas páginas para fins de reutilização. Então, o que eu fiz foi criar um atributo personalizado que verifica exclusões

public class ValidateAttribute : ActionFilterAttribute
{
    public string Exclude { get; set; }
    public string Base { get; set; }
    public override void OnActionExecuting(HttpActionContext actionContext)
    {
        if (!string.IsNullOrWhiteSpace(this.Exclude))
        {
            string[] excludes = this.Exclude.Split(',');
            foreach (var exclude in excludes)
            {
                actionContext.ModelState.Remove(Base + "." + exclude);
            }
        }
        if (actionContext.ModelState.IsValid == false)
        {
            var mediaType = new MediaTypeHeaderValue("application/json");
            var error = actionContext.ModelState;

            actionContext.Response = actionContext.Request.CreateResponse(HttpStatusCode.OK, error.Keys, mediaType);

        }
    }
}

e no seu controlador

[Validate(Base= "person",Exclude ="Age,Name")]
    public async Task<IHttpActionResult> Save(User person)
    {

            //do something           

    }

Digamos que o modelo é

public class User
{
    public int Id { get; set; }
    [Required]
    public string Name { get; set; }
    [Range(18,99)]
    public string Age { get; set; }
    [MaxLength(250)]
    public string Address { get; set; }
}

Sim, é possível desativar o Atributo necessário. Crie seu próprio atributo de classe personalizada (código de exemplo chamado ChangeableRequired) na extensão de RequiredAtribute e adicione uma Disabled Property e substitua o método IsValid para verificar se está desbalanceado. Use a reflexão para definir o poperty desativado, da seguinte maneira:

Atributo personalizado:

namespace System.ComponentModel.DataAnnotations
{
    public class ChangeableRequired : RequiredAttribute
    {
       public bool Disabled { get; set; }

       public override bool IsValid(object value)
       {
          if (Disabled)
          {
            return true;
          }

          return base.IsValid(value);
       }
    }
}

Atualize sua propriedade para usar seu novo atributo personalizado:

 class Forex
 {
 ....
    [ChangeableRequired]
    public decimal? ExchangeRate {get;set;}
 ....
 }

onde você precisa desativar a propriedade, use a reflexão para defini-la:

Forex forex = new Forex();
// Get Property Descriptor from instance with the Property name
PropertyDescriptor descriptor = TypeDescriptor.GetProperties(forex.GetType())["ExchangeRate"];
//Search for Attribute
ChangeableRequired attrib =  (ChangeableRequired)descriptor.Attributes[typeof(ChangeableRequired)];

// Set Attribute to true to Disable
attrib.Disabled = true;

Isso é agradável e limpo?

Nota: a validação acima será desativada enquanto a instância do seu objeto estiver ativa \ ativa ...