Disabilitare l'attributo di convalida richiesto in determinate circostanze

Mi chiedevo se è possibile disabilitare l'attributo di convalida richiesto in determinate azioni del controller. Mi chiedo questo perché su uno dei miei moduli di modifica non ho bisogno che l'utente inserisca valori per i campi che hanno già specificato in precedenza. Tuttavia implemento quindi la logica che quando immettono un valore utilizza una logica speciale per aggiornare il modello, come l'hashing di un valore, ecc.

Qualche suggerimento su come aggirare questo problema?

EDIT:
E sì, la convalida del client è un problema qui, in quanto non consentirà loro di inviare il modulo senza immettere un valore.

Questo problema può essere facilmente risolto utilizzando i modelli di visualizzazione. I modelli di vista sono classi specificamente adattate alle esigenze di una determinata vista. Ad esempio, nel tuo caso potresti avere i seguenti modelli di visualizzazione:

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

    ... some other properties
}

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

    ... some other properties
}

che verrà utilizzato nelle rispettive azioni del controller:

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

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

Se si desidera solo disabilitare la convalida per un singolo campo nel lato client, è possibile sovrascrivere gli attributi di convalida come segue:

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

So che questa domanda ha avuto risposta molto tempo fa e la risposta accettata farà davvero il lavoro. Ma c'è una cosa che mi preoccupa: dover copiare 2 modelli solo per disabilitare una convalida.

Ecco il mio suggerimento:

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

In questo modo, non devi preoccuparti delle convalide lato client / server, il framework si comporterà come dovrebbe. Inoltre, se si definisce un [Display]attributo sulla classe base, non è necessario ridefinirlo nel proprio UpdateModel.

E puoi ancora usare queste classi allo stesso modo:

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

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

È possibile rimuovere tutta la convalida da una proprietà con quanto segue nell'azione del controller.

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

@ Commento di Ian su MVC5

Quanto segue è ancora possibile

ModelState.Remove("PropertyNameInModel");

È un po 'fastidioso perdere la digitazione statica con l'API aggiornata. Puoi ottenere qualcosa di simile al vecchio modo creando un'istanza di helper HTML e usando i metodi NameExtensions .

Lato client Per disabilitare la convalida di un modulo, di seguito vengono fornite più opzioni basate sulla mia ricerca. Si spera che uno di loro lavorerebbe per te.

opzione 1

Preferisco questo e questo funziona perfettamente per me.

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

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

e invocandolo come

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

opzione 2

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

Opzione 3

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

Opzione 4

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

Opzione 5

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

Lato server

Crea un attributo e segna il tuo metodo di azione con quell'attributo. Personalizza questo per adattarsi alle tue esigenze specifiche.

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

Qui è stato descritto un approccio migliore Abilitare / disabilitare la convalida lato server mvc in modo dinamico

Personalmente tenderei ad usare l'approccio che Darin Dimitrov ha mostrato nella sua soluzione. Ciò consente di utilizzare l'approccio di annotazione dei dati con convalida E di disporre di attributi di dati separati su ciascun ViewModel corrispondente all'attività in corso. Per ridurre al minimo la quantità di lavoro per la copia tra modello e viewmodel dovresti guardare AutoMapper o ValueInjecter . Entrambi hanno i loro punti di forza individuali, quindi controllali entrambi.

Un altro possibile approccio per te sarebbe derivare il tuo modello o modello di visualizzazione da IValidatableObject. Questo ti dà la possibilità di implementare una funzione Convalida. In validate è possibile restituire un elenco di elementi ValidationResult o emettere un rendimento per ogni problema rilevato in validazione.

ValidationResult è costituito da un messaggio di errore e da un elenco di stringhe con i nomi dei campi. I messaggi di errore verranno visualizzati in una posizione vicino ai campi di input.

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

Credo che il modo più pulito qui disabiliterà la convalida lato client e sul lato server dovrai:

1. ModelState ["SomeField"]. Errors.Clear (nel controller o creare un filtro azioni per rimuovere gli errori prima dell'esecuzione del codice del controller)
2. Aggiungi ModelState.AddModelError dal codice del controller quando rilevi una violazione dei problemi rilevati.

Sembra che anche un modello di visualizzazione personalizzato qui non risolva il problema perché il numero di questi campi "pre-risposta" potrebbe variare. In caso contrario, un modello di visualizzazione personalizzato potrebbe effettivamente essere il modo più semplice, ma utilizzando la tecnica sopra è possibile aggirare i problemi di convalida.

questa era la risposta di qualcun altro nei commenti ... ma dovrebbe essere una vera risposta:

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

testato su MVC 6 con un campo con l' [Required]attributo

risposta rubata da https://stackoverflow.com/users/73382/rob sopra

Ho riscontrato questo problema durante la creazione di una vista di modifica per il mio modello e voglio aggiornare solo un campo.

La mia soluzione per un modo più semplice è mettere i due campi usando:

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

Commenti è il campo che aggiorno solo in Vista di modifica, che non ha Attributo richiesto.

ASP.NET MVC 3 Entity

AFAIK non puoi rimuovere l'attributo in fase di runtime, ma solo modificarne i valori (es: readonly true / false) cerca qui qualcosa di simile . Come altro modo di fare quello che vuoi senza fare confusione con gli attributi, andrò con un ViewModel per la tua azione specifica in modo da poter inserire tutta la logica senza rompere la logica richiesta da altri controller. Se si tenta di ottenere una sorta di procedura guidata (un modulo a più passaggi) è possibile invece serializzare i campi già compilati e con TempData portarli lungo i passi. (per assistenza nella serializzazione della deserializzazione è possibile utilizzare i futures MVC )

Quello che ha detto @Darin è anche quello che consiglierei. Tuttavia aggiungerei ad esso (e in risposta a uno dei commenti) che in realtà puoi anche usare questo metodo per tipi primitivi come bit, bool, persino strutture come Guid semplicemente rendendoli nulli. Una volta fatto questo, l' Requiredattributo funziona come previsto.

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 partire da MVC 5 questo può essere facilmente ottenuto aggiungendo questo nel tuo global.asax.

DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes = false;

Stavo cercando una soluzione in cui poter utilizzare lo stesso modello per un inserimento e un aggiornamento in API Web. Nella mia situazione è sempre un contenuto corporeo. Gli [Requiered]attributi devono essere ignorati se si tratta di un metodo di aggiornamento. Nella mia soluzione, metti un attributo [IgnoreRequiredValidations]sopra il metodo. Questo è il seguente:

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

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

    ...

Cos'altro bisogna fare? Un proprio BodyModelValidator deve essere creato e aggiunto all'avvio. Questo è in HttpConfiguration e si presenta così: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());
        }

        ...

Il mio BodyModelValidator è derivato da DefaultBodyModelValidator. E ho capito che dovevo scavalcare il metodo 'ShallowValidate'. In questa sostituzione ho filtrato i validatori del modello richiesti. E ora la classe IgnoreRequiredOrDefaultBodyModelValidator e la classe di attributo 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
    {

    }
}

fonti:

• Usando string debug = new StackTrace().ToString()per scoprire chi sta gestendo la validazione del modello.
• https://docs.microsoft.com/en-us/aspnet/web-api/overview/advanced/configuring-aspnet-web-api per sapere come impostare il mio validatore.
• https://github.com/ASP-NET-MVC/aspnetwebstack/blob/master/src/System.Web.Http/Validation/DefaultBodyModelValidator.cs per capire cosa sta facendo questo validatore.
• https://github.com/Microsoft/referencesource/blob/master/System.Web/ModelBinding/DataAnnotationsModelValidator.cs per capire perché la proprietà IsRequired è impostata su true. Qui puoi anche trovare l'attributo originale come proprietà.

Se non si desidera utilizzare un altro ViewModel, è possibile disabilitare le convalide client nella vista e rimuovere anche le convalide sul server per quelle proprietà che si desidera ignorare. Controlla questa risposta per una spiegazione più approfondita https://stackoverflow.com/a/15248790/1128216

Nel mio caso lo stesso modello è stato utilizzato in molte pagine per scopi di riutilizzabilità. Quindi quello che ho fatto è stato creare un attributo personalizzato che verifica le esclusioni

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 nel tuo controller

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

            //do something           

    }

Di 'che il modello è

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

Sì, è possibile disabilitare l'attributo richiesto. Crea il tuo attributo di classe personalizzato (codice di esempio chiamato ChangeableRequired) per estenderlo da RequiredAtribute e aggiungere una proprietà disabilitata e sovrascrivere il metodo IsValid per verificare se è sbilanciato. Usa la riflessione per impostare la popolazione disabilitata, in questo modo:

Attributo personalizzato:

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

Aggiorna la tua proprietà per utilizzare il nuovo attributo personalizzato:

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

dove devi disabilitare la proprietà usa reflection per impostarla:

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;

È bello e pulito?

NB: la convalida sopra sarà disabilitata mentre l'istanza dell'oggetto è attiva \ attiva ...