Désactiver l'attribut de validation obligatoire dans certaines circonstances

Je me demandais s'il était possible de désactiver l'attribut de validation requis dans certaines actions du contrôleur. Je me demande cela car sur l'un de mes formulaires d'édition, je n'oblige pas l'utilisateur à saisir des valeurs pour les champs qu'il a déjà spécifiés précédemment. Cependant, j'implémente ensuite une logique selon laquelle lorsqu'ils entrent une valeur, ils utilisent une logique spéciale pour mettre à jour le modèle, comme le hachage d'une valeur, etc.

Des suggestions pour contourner ce problème?

EDIT:
Et oui, la validation du client est un problème ici, car elle ne leur permettra pas de soumettre le formulaire sans entrer une valeur.

Ce problème peut être facilement résolu en utilisant des modèles de vue. Les modèles de vue sont des classes spécifiquement adaptées aux besoins d'une vue donnée. Par exemple, dans votre cas, vous pourriez avoir les modèles de vue suivants:

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

    ... some other properties
}

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

    ... some other properties
}

qui seront utilisés dans leurs actions de contrôleur correspondantes:

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

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

Si vous souhaitez simplement désactiver la validation pour un seul champ côté client, vous pouvez remplacer les attributs de validation comme suit:

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

Je sais que cette question a reçu une réponse il y a longtemps et que la réponse acceptée fera réellement le travail. Mais il y a une chose qui me dérange: ne devoir copier que 2 modèles pour désactiver une validation.

Voici ma suggestion:

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; }
    }
}

De cette façon, vous n'avez pas à vous soucier des validations côté client / serveur, le framework se comportera comme il est censé le faire. De plus, si vous définissez un [Display]attribut sur la classe de base, vous n'avez pas à le redéfinir dans votre fichier UpdateModel.

Et vous pouvez toujours utiliser ces classes de la même manière:

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

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

Vous pouvez supprimer toute validation d'une propriété avec ce qui suit dans votre action de contrôleur.

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

Commentaire de @ Ian concernant MVC5

Ce qui suit est toujours possible

ModelState.Remove("PropertyNameInModel");

Peu ennuyeux que vous perdiez la saisie statique avec l'API mise à jour. Vous pouvez réaliser quelque chose de similaire à l'ancienne méthode en créant une instance de l'aide HTML et en utilisant les méthodes NameExtensions .

Côté client Pour désactiver la validation d'un formulaire, plusieurs options basées sur mes recherches sont données ci-dessous. J'espère que l'un d'eux fonctionnera pour vous.

Option 1

Je préfère cela, et cela fonctionne parfaitement pour moi.

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

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

et l'invoquant comme

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

Option 2

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

Option 3

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

Option 4

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

Option 5

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

Du côté serveur

Créez un attribut et marquez votre méthode d'action avec cet attribut. Personnalisez-le pour l'adapter à vos besoins spécifiques.

[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();
        }
    }
}

Une meilleure approche a été décrite ici Activer / Désactiver dynamiquement la validation côté serveur mvc

Personnellement, j'aurais tendance à utiliser l'approche de Darin Dimitrov dans sa solution. Cela vous permet de pouvoir utiliser l'approche d'annotation de données avec validation ET d'avoir des attributs de données séparés sur chaque ViewModel correspondant à la tâche à accomplir. Pour minimiser la quantité de travail pour la copie entre le modèle et le modèle de vue, vous devez examiner AutoMapper ou ValueInjecter . Les deux ont leurs points forts individuels, alors vérifiez-les tous les deux.

Une autre approche possible pour vous serait de dériver votre viewmodel ou model de IValidatableObject. Cela vous donne la possibilité d'implémenter une fonction Valider. Dans validate, vous pouvez renvoyer une liste d'éléments ValidationResult ou émettre un retour de rendement pour chaque problème détecté lors de la validation.

Le ValidationResult se compose d'un message d'erreur et d'une liste de chaînes avec les noms de champ. Les messages d'erreur seront affichés à un emplacement près du ou des champs d'entrée.

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;
}

Le moyen le plus propre ici, je pense, va désactiver votre validation côté client et du côté serveur, vous devrez:

1. ModelState ["SomeField"]. Errors.Clear (dans votre contrôleur ou créez un filtre d'action pour supprimer les erreurs avant l'exécution du code du contrôleur)
2. Ajoutez ModelState.AddModelError à partir du code de votre contrôleur lorsque vous détectez une violation de vos problèmes détectés.

Il semble que même un modèle de vue personnalisé ici ne résoudra pas le problème car le nombre de ces champs «pré-répondus» pourrait varier. Si ce n'est pas le cas, un modèle de vue personnalisé peut en effet être le moyen le plus simple, mais en utilisant la technique ci-dessus, vous pouvez contourner vos problèmes de validation.

c'était la réponse de quelqu'un d'autre dans les commentaires ... mais cela devrait être une vraie réponse:

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

testé sur MVC 6 avec un champ ayant l' [Required]attribut

réponse volée sur https://stackoverflow.com/users/73382/rob ci-dessus

J'avais ce problème lors de la création d'une vue d'édition pour mon modèle et je souhaite mettre à jour un seul champ.

Ma solution pour la manière la plus simple est de mettre les deux champs en utilisant:

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

Les commentaires sont le champ que je mets à jour uniquement dans la vue d'édition, qui n'a pas d'attribut requis.

Entité ASP.NET MVC 3

AFAIK vous ne pouvez pas supprimer l'attribut au moment de l'exécution, mais seulement changer leurs valeurs (c'est-à-dire: lecture seule vrai / faux) cherchez ici quelque chose de similaire . Comme autre façon de faire ce que vous voulez sans déranger les attributs, j'irai avec un ViewModel pour votre action spécifique afin que vous puissiez insérer toute la logique sans casser la logique nécessaire aux autres contrôleurs. Si vous essayez d'obtenir une sorte d'assistant (un formulaire à plusieurs étapes), vous pouvez à la place sérialiser les champs déjà compilés et avec TempData les amener le long de vos étapes. (pour obtenir de l'aide sur la sérialisation de la désérialisation, vous pouvez utiliser les futurs MVC )

Ce que @Darin a dit est ce que je recommanderais également. Cependant, j'ajouterais (et en réponse à l'un des commentaires) que vous pouvez en fait également utiliser cette méthode pour les types primitifs comme bit, bool, même des structures comme Guid en les rendant simplement nullables. Une fois que vous faites cela, l' Requiredattribut fonctionne comme prévu.

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
}

À partir de MVC 5, cela peut être facilement réalisé en ajoutant ceci dans votre fichier global.asax.

DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes = false;

Je cherchais une solution où je peux utiliser le même modèle pour une insertion et une mise à jour dans l'API Web. Dans ma situation, est-ce toujours un contenu corporel. Les [Requiered]attributs doivent être ignorés s'il s'agit d'une méthode de mise à jour. Dans ma solution, vous placez un attribut [IgnoreRequiredValidations]au-dessus de la méthode. C'est comme suit:

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

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

    ...

Que faut-il faire d'autre? Un propre BodyModelValidator doit être créé et ajouté au démarrage. Ceci est dans la HttpConfiguration et ressemble à ceci: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());
        }

        ...

Mon propre BodyModelValidator est dérivé de DefaultBodyModelValidator. Et je me suis rendu compte que je devais ignorer la méthode «ShallowValidate». Dans ce remplacement, je filtre les validateurs de modèle requis. Et maintenant, la classe IgnoreRequiredOrDefaultBodyModelValidator et la classe d'attribut 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
    {

    }
}

Sources:

• Utiliser string debug = new StackTrace().ToString()pour savoir qui gère la validation du modèle.
• https://docs.microsoft.com/en-us/aspnet/web-api/overview/advanced/configuring-aspnet-web-api pour savoir comment définir mon propre validateur.
• https://github.com/ASP-NET-MVC/aspnetwebstack/blob/master/src/System.Web.Http/Validation/DefaultBodyModelValidator.cs pour comprendre ce que fait ce validateur.
• https://github.com/Microsoft/referencesource/blob/master/System.Web/ModelBinding/DataAnnotationsModelValidator.cs pour comprendre pourquoi la propriété IsRequired est définie sur true. Ici, vous pouvez également trouver l'attribut d'origine en tant que propriété.

Si vous ne souhaitez pas utiliser un autre ViewModel, vous pouvez désactiver les validations client sur la vue et également supprimer les validations sur le serveur pour les propriétés que vous souhaitez ignorer. Veuillez vérifier cette réponse pour une explication plus approfondie https://stackoverflow.com/a/15248790/1128216

Dans mon cas, le même modèle a été utilisé dans de nombreuses pages à des fins de réutilisation. Donc ce que j'ai fait, c'est d'avoir créé un attribut personnalisé qui vérifie les exclusions

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);

        }
    }
}

et dans votre contrôleur

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

            //do something           

    }

Disons que le modèle est

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; }
}

Oui, il est possible de désactiver l'attribut requis. Créez votre propre attribut de classe personnalisé (exemple de code appelé ChangeableRequired) à partir de RequiredAtribute et ajoutez une propriété désactivée et remplacez la méthode IsValid pour vérifier si elle est déséquilibrée. Utilisez la réflexion pour définir la propriété désactivée, comme ceci:

Attribut personnalisé:

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);
       }
    }
}

Mettez à jour votre propriété pour utiliser votre nouvel attribut personnalisé:

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

où vous devez désactiver la propriété, utilisez la réflexion pour la définir:

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;

C'est agréable et propre?

NB: La validation ci-dessus sera désactivée tant que votre instance d'objet est vivante \ active ...