Belirli koşullar altında Gerekli doğrulama özelliğini devre dışı bırak

Belirli denetleyici eylemlerinde Gerekli doğrulama özelliğini devre dışı bırakmanın mümkün olup olmadığını merak ediyordum. Bunu merak ediyorum çünkü düzenleme formlarımdan birinde kullanıcının daha önce belirtmiş oldukları alanlar için değer girmesini gerektirmiyorum. Ancak daha sonra bir değer girdiklerinde, modeli güncellemek için bir değer hash gibi bazı özel mantık kullandıkları mantığını uygularım.

Bu sorunun üstesinden gelmek için herhangi bir sorunuz var mı?

DÜZENLEME:
Ve evet istemci doğrulama burada bir değerdir, çünkü bir değer girmeden formu göndermelerine izin vermez.

Bu sorun, görünüm modelleri kullanılarak kolayca çözülebilir. Görünüm modelleri, belirli bir görünümün ihtiyaçlarına göre özel olarak uyarlanmış sınıflardır. Örneğin, sizin durumunuzda aşağıdaki görünüm modellerine sahip olabilirsiniz:

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

    ... some other properties
}

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

    ... some other properties
}

ilgili denetleyici eylemlerinde kullanılacak:

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

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

İstemci tarafında tek bir alan için doğrulamayı devre dışı bırakmak istiyorsanız, doğrulama niteliklerini aşağıdaki gibi geçersiz kılabilirsiniz:

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

Bu sorunun uzun zaman önce yanıtlandığını biliyorum ve kabul edilen cevap aslında işi yapacak. Ama beni rahatsız eden bir şey var: 2 modeli sadece bir doğrulamayı devre dışı bırakmak için kopyalamak zorunda.

İşte benim önerim:

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

Bu şekilde, istemci / sunucu tarafı doğrulamaları ile uğraşmanıza gerek kalmaz, çerçeve olması gerektiği gibi davranır. Ayrıca, [Display]temel sınıfta bir öznitelik tanımlarsanız, bunu özniteliğinizde yeniden tanımlamanız gerekmez UpdateModel.

Ve yine de bu sınıfları aynı şekilde kullanabilirsiniz:

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

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

Denetleyici eyleminizde aşağıdakilerle bir özellik dışındaki tüm doğrulamaları kaldırabilirsiniz.

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

@ Ian'ın MVC5 ile ilgili yorumu

Aşağıdakiler hala mümkündür

ModelState.Remove("PropertyNameInModel");

Güncellenmiş API ile statik yazmayı kaybetmeniz biraz can sıkıcı. HTML yardımcısının bir örneğini oluşturarak ve NameExtensions Yöntemlerini kullanarak eski yolla benzer bir şey elde edebilirsiniz .

İstemci tarafı Bir form için doğrulamayı devre dışı bırakmak amacıyla, araştırmamı temel alan birden çok seçenek aşağıda verilmiştir. Bunlardan biri umarım sizin için çalışır.

seçenek 1

Bunu tercih ederim ve bu benim için mükemmel bir şekilde çalışıyor.

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

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

ve şöyle çağırıyor

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

seçenek 2

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

Seçenek 3

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

Seçenek 4

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

Seçenek 5

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

Sunucu Tarafı

Bir özellik oluşturun ve eylem yönteminizi bu özellik ile işaretleyin. Özel ihtiyaçlarınıza uyarlamak için bunu özelleştirin.

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

Daha iyi bir yaklaşım burada açıklanmıştır. Mvc sunucu tarafı doğrulamasını dinamik olarak etkinleştirme / devre dışı bırakma

Şahsen Darin Dimitrov'un çözümünde gösterdiği yaklaşımı kullanma eğilimindeydim. Bu, veri notlandırma yaklaşımını doğrulama ile kullanabilmenizi sağlar ve eldeki göreve karşılık gelen her ViewModel'de ayrı veri özelliklerine sahiptir. Model ve viewmodel arasında kopyalama işini en aza indirmek için AutoMapper veya ValueInjecter'e bakmalısınız . Her ikisinin de kendine özgü güçlü noktaları vardır, bu yüzden ikisini de kontrol edin.

Sizin için başka bir olası yaklaşım, modelinizi veya modelinizi IValidatableObject'ten türetmek olacaktır. Bu size bir Validate işlevi uygulama seçeneği sunar. Doğrulamada, bir ValidationResult öğeleri listesi döndürebilir veya doğrulamada algıladığınız her sorun için bir getiri getirisi verebilirsiniz.

ValidationResult bir hata iletisinden ve alan adlarına sahip dizelerden oluşan bir listeden oluşur. Hata mesajları giriş alan (lar) ına yakın bir yerde gösterilecektir.

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

Buradaki en temiz yol, istemci tarafı doğrulamanızı devre dışı bırakacağına ve sunucu tarafında şunları yapmanız gerektiğine inanıyorum:

1. ModelState ["SomeField"]. Hatalar.Temizle (denetleyicinizde veya denetleyici kodu yürütülmeden önce hataları kaldırmak için bir eylem filtresi oluşturun)
2. Tespit ettiğiniz sorunların ihlal edildiğini tespit ettiğinizde denetleyici kodunuzdan ModelState.AddModelError öğesini ekleyin.

Burada özel bir görünüm modeli bile sorunu çözmeyecek gibi görünüyor, çünkü bu 'önceden cevaplanan' alanların sayısı değişebilir. Özel bir görünüm modeli yoksa, en kolay yol olabilir, ancak yukarıdaki tekniği kullanarak doğrulama sorunlarınızı çözebilirsiniz.

bu yorumlarda başkasının cevabı idi ... ama gerçek bir cevap olmalı:

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

MVC 6'da bu [Required]özelliğe sahip bir alanla test edildi

çalınan cevaplamak https://stackoverflow.com/users/73382/rob yukarıda

Modelim için bir Düzenleme Görünümü oluştururken bu sorunu yaşıyordum ve yalnızca bir alanı güncellemek istiyorum.

En basit yol için çözümüm, iki alanı aşağıdakileri kullanarak koymaktır:

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

Yorumlar, yalnızca Düzenleme Görünümü'nde güncellediğim ve Gerekli Özniteliğe sahip olmayan alandır.

ASP.NET MVC 3 Varlığı

AFAIK, çalışma zamanında özniteliği kaldıramazsınız, ancak yalnızca değerlerini değiştirirsiniz (yani: salt okunur doğru / yanlış) benzer bir şey için buraya bakın . Özniteliklerle uğraşmadan istediğinizi yapmanın başka bir yolu olarak, özel kontrolünüz için bir ViewModel ile gideceğim, böylece diğer kontrol cihazlarının ihtiyaç duyduğu mantığı bozmadan tüm mantığı ekleyebilirsiniz. Bir çeşit sihirbaz (çok adımlı form) elde etmeye çalışırsanız, bunun yerine zaten derlenmiş alanları serileştirebilirsiniz ve TempData ile bunları adımlarınız boyunca getirin. (serileştirmeyi serileştirme konusunda yardım için MVC vadeli işlemlerini kullanabilirsiniz )

@ Darin dedi ne de tavsiye ederim. Bununla birlikte, aslında bu yöntemi bit, bool, hatta Guid gibi yapılar için ilkel tipler için sadece onları null edilebilir hale getirerek kullanabileceğinizi (ve yorumlardan birine yanıt olarak) ekleyeceğim. Bunu yaptıktan sonra, Requiredözellik beklendiği gibi çalışır.

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
}

MVC 5'ten itibaren bunu bunu bilgisayarınıza ekleyerek kolayca elde edebilirsiniz global.asax.

DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes = false;

Web API'sinde bir ekleme ve güncelleme için aynı modeli kullanabileceğim bir çözüm arıyordum. Benim durumumda bu her zaman bir vücut içeriğidir. [Requiered]Bir güncellemenin yöntemi ise nitelikler atlanır gerekir. Benim çözümümde, [IgnoreRequiredValidations]yöntemin üstüne bir öznitelik yerleştirirsiniz . Bu aşağıdaki gibidir:

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

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

    ...

Başka ne yapılması gerekiyor? Başlangıçta kendi bir BodyModelValidator oluşturulmalı ve eklenmelidir. Bu HttpConfiguration içinde ve şöyle görünüyor: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());
        }

        ...

Kendi BodyModelValidator'ım DefaultBodyModelValidator'dan türetildi. Ve 'ShallowValidate' yöntemini geçersiz kılmak zorunda olduğumu anladım. Bu geçersiz kılmada, gerekli model doğrulayıcılarına filtre uygularım. Ve şimdi IgnoreRequiredOrDefaultBodyModelValidator sınıfı ve IgnoreRequiredValidations öznitelik sınıfı:

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
    {

    }
}

Kaynaklar:

• string debug = new StackTrace().ToString()Model doğrulamasını kimin teslim ettiğini bulmak için kullanılır .
• Kendi doğrulayıcımı nasıl ayarlayacağımı öğrenmek için https://docs.microsoft.com/en-us/aspnet/web-api/overview/advanced/configuring-aspnet-web-api .
• Bu doğrulayıcının ne yaptığını anlamak için https://github.com/ASP-NET-MVC/aspnetwebstack/blob/master/src/System.Web.Http/Validation/DefaultBodyModelValidator.cs .
• IsRequired özelliğinin neden doğru olarak ayarlandığını anlamak için https://github.com/Microsoft/referencesource/blob/master/System.Web/ModelBinding/DataAnnotationsModelValidator.cs . Burada orijinal Nitelik'i özellik olarak da bulabilirsiniz.

Başka bir ViewModel kullanmak istemiyorsanız, görünümdeki istemci doğrulamalarını devre dışı bırakabilir ve yok saymak istediğiniz özellikler için sunucudaki doğrulamaları kaldırabilirsiniz. Daha derin bir açıklama için lütfen bu cevabı kontrol edin https://stackoverflow.com/a/15248790/1128216

Benim durumumda aynı Model yeniden kullanılabilirlik amacıyla birçok sayfada kullanıldı. Yani yaptığım şey, istisnaları kontrol eden özel bir özellik oluşturduğum

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

        }
    }
}

ve kumandanızda

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

            //do something           

    }

Modelin

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

Evet, Gerekli Öznitelik'i devre dışı bırakmak mümkündür. RequiredAtribute öğesinden genişlemek için kendi özel sınıf özniteliğinizi (ChangeableRequired adlı örnek kod) oluşturun ve Disabled özelliğini ekleyin ve disbaled olup olmadığını kontrol etmek için IsValid yöntemini geçersiz kılın. Devre dışı bırakılmış poperty'i ayarlamak için yansımayı kullanın, şöyle:

Özel Özellik:

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

Yeni özel Özelliğinizi kullanmak için mülkünüzü güncelleyin:

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

özelliği devre dışı bırakmak istediğiniz özelliği ayarlamak için yansımayı kullanın:

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;

Bu güzel ve temiz hissettiriyor mu?

Not: Nesne örneğiniz canlı \ etkinken yukarıdaki doğrulama devre dışı bırakılacak ...