ASP.NET Core MVC ve Razor Sayfalarda model doğrulama

Bu makalede, ASP.NET Core MVC veya Razor Pages uygulamasında kullanıcı girişinin nasıl doğrulanması açıklanır.

Örnek kodu görüntüleme veya indirme (indirme).

Model durumu

Model durumu, iki alt sistemden gelen hataları temsil eder: model bağlama ve model doğrulama. Model bağlamasından kaynaklanan hatalar genellikle veri dönüştürme hatalarıdır. Örneğin, bir tamsayı alanına "x" girilir. Model doğrulama, model bağlamadan sonra gerçekleşir ve verilerin iş kurallarına uymadığı hataları bildirir. Örneğin, derecelendirmenin 1 ile 5 arasında olmasını bekleyen bir alana 0 girilir.

Hem model bağlama hem de model doğrulama, bir denetleyici eyleminin veya Razor Pages işleyici yönteminin yürütülmesinden önce gerçekleşir. Web uygulamaları için, ModelState.IsValid kontrol etmek ve uygun şekilde tepki vermek uygulamanın sorumluluğundadır. Web uygulamaları genellikle aşağıdaki Razor Sayfalar örneğinde gösterildiği gibi sayfayı bir hata iletisiyle yeniden görüntüler:

public async Task<IActionResult> OnPostAsync()
{
    if (!ModelState.IsValid)
    {
        return Page();
    }

    _context.Movies.Add(Movie);
    await _context.SaveChangesAsync();

    return RedirectToPage("./Index");
}

Denetleyiciler ve görünümler içeren ASP.NET Core MVC için, aşağıdaki örnek bir denetleyici eylemi içinde ModelState.IsValid nasıl kontrol edileceğini göstermektedir.

public async Task<IActionResult> Create(Movie movie)
{
    if (!ModelState.IsValid)
    {
        return View(movie);
    }

    _context.Movies.Add(movie);
    await _context.SaveChangesAsync();

    return RedirectToAction(nameof(Index));
}

Web API denetleyicilerinin ModelState.IsValid [ApiController] niteliğine sahip olup olmadığını kontrol etmeleri gerekmez. Bu durumda, model durumu geçersiz olduğunda hata ayrıntılarını içeren otomatik bir HTTP 400 yanıtı döndürülür. Daha fazla bilgi için bkz . Otomatik HTTP 400 yanıtları.

Doğrulamayı yeniden çalıştırma

Doğrulama otomatiktir, ancak el ile yinelemek isteyebilirsiniz. Örneğin, bir özellik için bir değer hesaplayabilirsiniz ve özelliği hesaplanan değere ayarladıktan sonra doğrulamayı yeniden çalıştırmak isteyebilirsiniz. Doğrulamayı yeniden çalıştırmak için, doğrulanan modele özgü doğrulamayı temizlemek amacıyla ModelStateDictionary.ClearValidationState öğesini çağırın, ardından TryValidateModel öğesini uygulayın.

public async Task<IActionResult> OnPostTryValidateAsync()
{
    var modifiedReleaseDate = DateTime.Now.Date;
    Movie.ReleaseDate = modifiedReleaseDate;

    ModelState.ClearValidationState(nameof(Movie));
    if (!TryValidateModel(Movie, nameof(Movie)))
    {
        return Page();
    }

    _context.Movies.Add(Movie);
    await _context.SaveChangesAsync();

    return RedirectToPage("./Index");
}

Doğrulama öznitelikleri

Doğrulama öznitelikleri, model özellikleri için doğrulama kuralları belirtmenize olanak sağlar. Örnek uygulamadan alınan aşağıdaki örnekte, doğrulama öznitelikleriyle açıklama eklenen bir model sınıfı gösterilmektedir. [ClassicMovie] özniteliği özel bir doğrulama özniteliğidir ve diğerleri yerleşiktir. Gösterilmeyen [ClassicMovieWithClientValidator], özel bir öznitelik uygulamak için alternatif bir yol gösterir.

public class Movie
{
    public int Id { get; set; }

    [Required]
    [StringLength(100)]
    public string Title { get; set; } = null!;

    [ClassicMovie(1960)]
    [DataType(DataType.Date)]
    [Display(Name = "Release Date")]
    public DateTime ReleaseDate { get; set; }

    [Required]
    [StringLength(1000)]
    public string Description { get; set; } = null!;

    [Range(0, 999.99)]
    public decimal Price { get; set; }

    public Genre Genre { get; set; }

    public bool Preorder { get; set; }
}

Yerleşik öznitelikler

Doğrulama özniteliklerinin tam listesi için ad alanına System.ComponentModel.DataAnnotations bakın.

Hata iletileri

Doğrulama öznitelikleri, geçersiz giriş için görüntülenecek hata iletisini belirtmenize olanak sağlar. Örneğin:

[StringLength(8, ErrorMessage = "Name length can't be more than 8.")]

Öznitelikler dahili olarak, alan adı için bir yer tutucu ve bazen ek yer tutucularla String.Format'ü çağırır. Örneğin:

[StringLength(8, ErrorMessage = "{0} length must be between {2} and {1}.", MinimumLength = 6)]

Bir Name özelliğe uygulandığında, önceki kod tarafından oluşturulan hata iletisi "Ad uzunluğu 6 ile 8 arasında olmalıdır".

Belirli bir özniteliğin hata iletisi için hangi parametrelerin String.Format'e geçirildiğini öğrenmek için DataAnnotations kaynak koduna bakınız.

Doğrulama hatalarında JSON özellik adlarını kullanma

Varsayılan olarak, bir doğrulama hatası oluştuğunda model doğrulaması, hata anahtarı olarak özellik adıyla bir ModelStateDictionary oluşturur. Tek sayfalı uygulamalar gibi bazı uygulamalar, Web API'lerinden oluşturulan doğrulama hataları için JSON özellik adlarının kullanılmasından yararlanmaktadır. Aşağıdaki kod, SystemTextJsonValidationMetadataProvider öğesini kullanarak, JSON özellik adlarını kullanmak için doğrulamayı yapılandırmaktadır.

using Microsoft.AspNetCore.Mvc.ModelBinding.Metadata;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers(options =>
{
    options.ModelMetadataDetailsProviders.Add(new SystemTextJsonValidationMetadataProvider());
});

var app = builder.Build();

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

Aşağıdaki kod, Json.NET kullanırken NewtonsoftJsonValidationMetadataProvider JSON özellik adını kullanmak için doğrulamayı yapılandırmaktadır:

using Microsoft.AspNetCore.Mvc.NewtonsoftJson;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers(options =>
{
    options.ModelMetadataDetailsProviders.Add(new NewtonsoftJsonValidationMetadataProvider());
}).AddNewtonsoftJson();

var app = builder.Build();

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

Camel-casing kullanma ilkesi örneği için GitHub'daki Program.cs bölümüne bakın.

Null değer atanamayan referans türleri ve [Gerekli] özelliği

Doğrulama sistemi, null değer atanamayan parametreleri veya ilişkili özellikleri bir [Required(AllowEmptyStrings = true)] özniteliği varmış gibi ele alır. Bağlamları Nullable etkinleştirerek, MVC, boş değer atanamayan özellikleri veya parametreleri, sanki [Required(AllowEmptyStrings = true)] özniteliğiyle ilişkilendirilmiş gibi örtük olarak doğrulamaya başlar. Aşağıdaki kodu inceleyin:

public class Person
{
    public string Name { get; set; }
}

** Uygulama <Nullable>enable</Nullable> ile oluşturulduysa, bir JSON veya form gönderisinde Name için eksik bir değer doğrulama hatasıyla sonuçlanır. Öznitelik örtülü olduğundan [Required(AllowEmptyStrings = true)] bu çelişkili görünebilir, ancak boş dizeler varsayılan olarak null değerine dönüştürüldüğünden bu beklenen bir davranıştır. Özellik için null veya eksik değerlerin belirtilmesine imkan tanımak amacıyla null değer alabilen bir başvuru türü kullanın:

public class Person
{
    public string? Name { get; set; }
}

Bu davranış, SuppressImplicitRequiredAttributeForNonNullableReferenceTypes içindeki Program.cs yapılandırılarak devre dışı bırakılabilir.

builder.Services.AddControllers(
    options => options.SuppressImplicitRequiredAttributeForNonNullableReferenceTypes = true);

Sunucuda [Gerekli] doğrulama

Sunucuda, özellik null olduğunda gerekli bir değerin eksik olduğu kabul edilir. Null değer atanamayan bir alan her zaman geçerlidir ve özniteliğin [Required] hata iletisi hiçbir zaman görüntülenmez.

Ancak, null değer atanamayan bir özellik için model bağlama başarısız olabilir ve gibi The value '' is invalidbir hata iletisiyle sonuçlanabilir. Null değer atanamayan türlerin sunucu tarafı doğrulaması için özel bir hata iletisi belirtmek için aşağıdaki seçeneklere sahipsiniz:

• Alanı nullable yapın (örneğin, decimal? yerine decimal). Boş olabilir<T> değer türleri standart boş olabilir türler olarak kabul edilir.

• Aşağıdaki örnekte gösterildiği gibi model bağlaması tarafından kullanılacak varsayılan hata iletisini belirtin:

  builder.Services.AddRazorPages()
      .AddMvcOptions(options =>
      {
          options.MaxModelValidationErrors = 50;
          options.ModelBindingMessageProvider.SetValueMustNotBeNullAccessor(
              _ => "The field is required.");
      });
  
  builder.Services.AddSingleton
      <IValidationAttributeAdapterProvider, CustomValidationAttributeAdapterProvider>();
  

  Varsayılan iletileri ayarlayabileceğiniz model bağlama hataları hakkında daha fazla bilgi için bkz DefaultModelBindingMessageProvider. .

İstemci tarafında gerekli doğrulama

Null değer atanamayan türler ve dizeler istemcide sunucuyla karşılaştırıldığında farklı şekilde işlenir. İstemcide:

• Bir değerin mevcut sayıldığı, yalnızca bu değer için giriş yapıldığında kabul edilir. Bu nedenle, istemci tarafı doğrulama null atanamayan türleri, null atanabilir türlerle aynı şekilde ele alır.
• Dize alanındaki boşluk, jQuery Doğrulaması gerekli yöntemi tarafından geçerli giriş olarak kabul edilir. Sunucu tarafı doğrulaması, yalnızca boşluk girilirse zorunlu bir dize alanını geçersiz olarak sayar.

Daha önce belirtildiği gibi, null atanamayan türler bir [Required(AllowEmptyStrings = true)] özniteliği varmış gibi kabul edilir. Bu, [Required(AllowEmptyStrings = true)] özniteliğini uygulamasanız bile istemci tarafı doğrulamasını kesinlikle alacağınız anlamına gelir. Ancak özniteliğini kullanmazsanız varsayılan bir hata iletisi alırsınız. Özel bir hata iletisi belirtmek için özniteliğini kullanın.

[Remote] özniteliği

[Remote] özniteliği, alan girişinin geçerli olup olmadığını belirlemek için sunucuda bir yöntem çağırmayı gerektiren istemci tarafı doğrulaması uygular. Örneğin, uygulamanın bir kullanıcı adının zaten kullanımda olup olmadığını doğrulaması gerekebilir.

Uzaktan doğrulama uygulamak için:

1. JavaScript'in çağıracağı bir eylem yöntemi oluşturun. jQuery Doğrulama uzak yöntemi bir JSON yanıtı bekler:

   • true giriş verilerinin geçerli olduğu anlamına gelir.
   • false, undefinedveya null girişin geçersiz olduğu anlamına gelir. Varsayılan hata iletisini görüntüleyin.
   • Diğer dizeler girişin geçersiz olduğu anlamına gelir. Dizeyi özel bir hata iletisi olarak görüntüleyin.

   Aşağıda özel hata iletisi döndüren bir eylem yöntemi örneği verilmiştir:

   [AcceptVerbs("GET", "POST")]
   public IActionResult VerifyEmail(string email)
   {
       if (!_userService.VerifyEmail(email))
       {
           return Json($"Email {email} is already in use.");
       }
   
       return Json(true);
   }
   

2. Model sınıfında, aşağıdaki örnekte gösterildiği gibi doğrulama eylemi yöntemine işaret eden bir [Remote] öznitelikle özelliğine açıklama ekleyin:

   [Remote(action: "VerifyEmail", controller: "Users")]
   public string Email { get; set; } = null!;
   

Uzaktan doğrulama:

• Form gönderildikten sonra sunucu tarafı doğrulama gerçekleştirmez.
• İstemcinin JavaScript'i devre dışı bırakması durumunda istemci tarafı denetimleri gerçekleştirilmez. Sunucuda form işleme için istemci tarafı doğrulama denetimi gerekiyorsa, her zaman ayrı sunucu tarafı doğrulama uygulayın.

Ek alanlar

AdditionalFields özniteliğinin [Remote] özelliği, sunucudaki verilerde alan birleşimlerini doğrulamanıza olanak tanır. Örneğin, modelde UserFirstName ve LastName özellikleri varsa, mevcut kullanıcıların bu ad çiftine sahip olmadığını doğrulamak isteyebilirsiniz. Aşağıdaki örnekte nasıl kullanılacağı gösterilmektedir AdditionalFields:

[Remote(action: "VerifyName", controller: "Users", AdditionalFields = nameof(LastName))]
[Display(Name = "First Name")]
public string FirstName { get; set; } = null!;

[Remote(action: "VerifyName", controller: "Users", AdditionalFields = nameof(FirstName))]
[Display(Name = "Last Name")]
public string LastName { get; set; } = null!;

AdditionalFieldsaçıkça "FirstName" ve "LastName" dizelerine ayarlanabilir, ancak nameof işlecinin kullanılması daha sonra yeniden düzenlemeyi kolaylaştırır. Bu doğrulama için eylem yöntemi hem firstName hem de lastName bağımsız değişkenlerini kabul etmelidir.

[AcceptVerbs("GET", "POST")]
public IActionResult VerifyName(string firstName, string lastName)
{
    if (!_userService.VerifyName(firstName, lastName))
    {
        return Json($"A user named {firstName} {lastName} already exists.");
    }

    return Json(true);
}

Kullanıcı bir ad veya soyadı girdiğinde, JavaScript bu ad çiftinin alınıp alınmadığını görmek için uzak bir çağrı yapar.

İki veya daha fazla ek alanı doğrulamak için, bunları virgülle ayrılmış liste olarak sağlayın. Örneğin, modele özellik MiddleName eklemek için özniteliğini [Remote] aşağıdaki örnekte gösterildiği gibi ayarlayın:

[Remote(action: "VerifyName", controller: "Users",
    AdditionalFields = nameof(FirstName) + "," + nameof(LastName))]
public string MiddleName { get; set; }

AdditionalFields, tüm öznitelik bağımsız değişkenleri gibi sabit bir ifade olmalıdır. Bu nedenle, bir karakter dizisini başlatmak için veya Join çağrısı yapmak için AdditionalFields kullanmayın.

Yerleşik özniteliklere alternatifler

Yerleşik öznitelikler tarafından sağlanmayan doğrulamaya ihtiyacınız varsa şunları yapabilirsiniz:

• Özel öznitelikler oluşturun.
• IValidatableObject uygulayın.

Özel öznitelikler

Yerleşik doğrulama özniteliklerinin işlemediğini senaryolar için özel doğrulama öznitelikleri oluşturabilirsiniz. Bir ValidationAttribute öğesinden devralan bir sınıf oluşturun ve IsValid yöntemini geçersiz kılın.

IsValid yöntemi, doğrulanacak giriş olan value adlı bir nesneyi kabul eder. Aşırı yükleme, model bağlaması tarafından oluşturulan model örneği gibi ek bilgiler sağlayan bir ValidationContext nesneyi de kabul eder.

Aşağıdaki örnek, Klasik tarzdaki bir filmin yayın tarihinin belirtilen yıldan sonra olmadığını doğrular. Özniteliği [ClassicMovie] :

• Yalnızca sunucuda çalıştırılır.
• Klasik filmler için yayın tarihini doğrular:

public class ClassicMovieAttribute : ValidationAttribute
{
    public ClassicMovieAttribute(int year)
        => Year = year;

    public int Year { get; }

    public string GetErrorMessage() =>
        $"Classic movies must have a release year no later than {Year}.";

    protected override ValidationResult? IsValid(
        object? value, ValidationContext validationContext)
    {
        var movie = (Movie)validationContext.ObjectInstance;
        var releaseYear = ((DateTime)value!).Year;

        if (movie.Genre == Genre.Classic && releaseYear > Year)
        {
            return new ValidationResult(GetErrorMessage());
        }

        return ValidationResult.Success;
    }
}

movie Yukarıdaki örnekteki değişken, form gönderimindeki verileri içeren bir Movie nesneyi temsil eder. Doğrulama başarısız olduğunda, hata mesajı içeren bir ValidationResult nesnesi döndürülür.

IValidatableObject

Önceki örnek yalnızca Movie türleriyle çalışır. Sınıf düzeyi doğrulama için bir diğer seçenek de aşağıdaki örnekte gösterildiği gibi model sınıfında uygulamaktır IValidatableObject :

public class ValidatableMovie : IValidatableObject
{
    private const int _classicYear = 1960;

    public int Id { get; set; }

    [Required]
    [StringLength(100)]
    public string Title { get; set; } = null!;

    [DataType(DataType.Date)]
    [Display(Name = "Release Date")]
    public DateTime ReleaseDate { get; set; }

    [Required]
    [StringLength(1000)]
    public string Description { get; set; } = null!;

    [Range(0, 999.99)]
    public decimal Price { get; set; }

    public Genre Genre { get; set; }

    public bool Preorder { get; set; }

    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
    {
        if (Genre == Genre.Classic && ReleaseDate.Year > _classicYear)
        {
            yield return new ValidationResult(
                $"Classic movies must have a release year no later than {_classicYear}.",
                new[] { nameof(ReleaseDate) });
        }
    }
}

Özel doğrulama

Aşağıdaki kod, modeli inceledikten sonra bir model hatasının nasıl ekleneceğini gösterir:

if (Contact.Name == Contact.ShortName)
{
    ModelState.AddModelError("Contact.ShortName", 
                             "Short name can't be the same as Name.");
}

Aşağıdaki kod bir denetleyicide doğrulama testini uygular:

if (contact.Name == contact.ShortName)
{
    ModelState.AddModelError(nameof(contact.ShortName),
                             "Short name can't be the same as Name.");
}

Aşağıdaki kod, telefon numarasının ve e-postanın benzersiz olduğunu doğrular:

public async Task<IActionResult> OnPostAsync()
{
    // Attach Validation Error Message to the Model on validation failure.          

    if (Contact.Name == Contact.ShortName)
    {
        ModelState.AddModelError("Contact.ShortName", 
                                 "Short name can't be the same as Name.");
    }

    if (_context.Contact.Any(i => i.PhoneNumber == Contact.PhoneNumber))
    {
        ModelState.AddModelError("Contact.PhoneNumber",
                                  "The Phone number is already in use.");
    }
    if (_context.Contact.Any(i => i.Email == Contact.Email))
    {
        ModelState.AddModelError("Contact.Email", "The Email is already in use.");
    }

    if (!ModelState.IsValid || _context.Contact == null || Contact == null)
    {
        // if model is invalid, return the page with the model state errors.
        return Page();
    }
    _context.Contact.Add(Contact);
    await _context.SaveChangesAsync();

    return RedirectToPage("./Index");
}

Aşağıdaki kod bir denetleyicide doğrulama testini uygular:

[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Create([Bind("Id,Name,ShortName,Email,PhoneNumber")] Contact contact)
{
    // Attach Validation Error Message to the Model on validation failure.
    if (contact.Name == contact.ShortName)
    {
        ModelState.AddModelError(nameof(contact.ShortName),
                                 "Short name can't be the same as Name.");
    }

    if (_context.Contact.Any(i => i.PhoneNumber == contact.PhoneNumber))
    {
        ModelState.AddModelError(nameof(contact.PhoneNumber),
                                  "The Phone number is already in use.");
    }
    if (_context.Contact.Any(i => i.Email == contact.Email))
    {
        ModelState.AddModelError(nameof(contact.Email), "The Email is already in use.");
    }

    if (ModelState.IsValid)
    {
        _context.Add(contact);
        await _context.SaveChangesAsync();
        return RedirectToAction(nameof(Index));
    }
    return View(contact);
}

Benzersiz bir telefon numarasını veya e-postayı denetlemek genellikle uzaktan doğrulama kullanılarak yapılır.

ValidationResult

Aşağıdaki özel ValidateNameAttributedurumu göz önünde bulundurun:

public class ValidateNameAttribute : ValidationAttribute
{
    public ValidateNameAttribute()
    {
        const string defaultErrorMessage = "Error with Name";
        ErrorMessage ??= defaultErrorMessage;
    }

    protected override ValidationResult? IsValid(object? value,
                                         ValidationContext validationContext)
    {
        if (value == null || string.IsNullOrWhiteSpace(value.ToString()))
        {
            return new ValidationResult("Name is required.");
        }

        if (value.ToString()!.ToLower().Contains("zz"))
        {

            return new ValidationResult(
                        FormatErrorMessage(validationContext.DisplayName));
        }

        return ValidationResult.Success;
    }
}

Aşağıdaki kodda özel [ValidateName] öznitelik uygulanır:

public class Contact
{
    public Guid Id { get; set; }

    [ValidateName(ErrorMessage = "Name must not contain `zz`")] 
    public string? Name { get; set; }
    public string? Email { get; set; }
    public string? PhoneNumber { get; set; }
}

Model, zz içerdiğinde yeni bir ValidationResult döndürülür.

Üst düzey düğüm doğrulama

En üst düzey düğümler şunlardır:

• İşlem parametreleri
• Denetleyici özellikleri
• Sayfa işleyicisi parametreleri
• Sayfa modeli özellikleri

Modele bağlı üst düzey düğümler, model özelliklerini doğrulamaya ek olarak doğrulanır. Aşağıdaki örnek, örnek uygulamadan, VerifyPhone yöntemini, RegularExpressionAttribute eylem parametresini doğrulamak için phone öğesini kullanır.

[AcceptVerbs("GET", "POST")]
public IActionResult VerifyPhone(
    [RegularExpression(@"^\d{3}-\d{3}-\d{4}$")] string phone)
{
    if (!ModelState.IsValid)
    {
        return Json($"Phone {phone} has an invalid format. Format: ###-###-####");
    }

    return Json(true);
}

Üst düzey düğümler, doğrulama öznitelikleriyle BindRequiredAttribute kullanabilir. Örnek uygulamadan alınan aşağıdaki örnekte, yöntemi, form gönderildiğinde CheckAge parametresinin sorgu dizesinden bağlanması gerektiğini belirtir.

[HttpPost]
public IActionResult CheckAge([BindRequired, FromQuery] int age)
{

Yaşı Denetle sayfasında ()CheckAge.cshtml iki form vardır. İlk form, Age99 değerini bir sorgu dizesi parametresi olarak gönderir: https://localhost:5001/Users/CheckAge?Age=99.

Sorgu dizesinden düzgün biçimlendirilmiş age bir parametre gönderildiğinde, form doğrulanır.

Yaşı Kontrol et sayfasındaki ikinci form, isteğin gövdesindeki Age değerini gönderir ve doğrulama başarısız olur. Parametrenin bir sorgu dizesinden gelmesi gerektiğinden age bağlama başarısız oluyor.

En fazla hata sayısı

Maksimum hata sayısına (varsayılan olarak 200) ulaşıldığında doğrulama durdurulur. Bu sayıyı içinde Program.csaşağıdaki kodla yapılandırabilirsiniz:

builder.Services.AddRazorPages()
    .AddMvcOptions(options =>
    {
        options.MaxModelValidationErrors = 50;
        options.ModelBindingMessageProvider.SetValueMustNotBeNullAccessor(
            _ => "The field is required.");
    });

builder.Services.AddSingleton
    <IValidationAttributeAdapterProvider, CustomValidationAttributeAdapterProvider>();

Maksimum özyineleme derinliği

ValidationVisitor doğrulanan modelin nesne grafını gezer. Derin veya sonsuz özyinelemeli modeller için doğrulama, yığın taşmasına neden olabilir. MvcOptions.MaxValidationDepth , ziyaretçi özyinelemesi yapılandırılmış bir derinliği aşarsa doğrulamayı erken durdurmanın bir yolunu sağlar. varsayılan değeri MvcOptions.MaxValidationDepth 32'dir.

Otomatik kısa devre

Model grafı doğrulama gerektirmiyorsa doğrulama otomatik olarak kısa devreli (atlanır) olur. Çalışma zamanının doğrulamayı atladığı nesneler, ilkel tür koleksiyonlarını (byte[], string[], Dictionary<string, string> gibi) ve doğrulayıcıları bulunmayan karmaşık nesne graflarını içerir.

İstemci tarafı doğrulama

İstemci tarafı doğrulama, form geçerli olana kadar gönderimi engeller. Gönder düğmesi formu gönderen veya hata iletileri görüntüleyen JavaScript'i çalıştırır.

İstemci tarafı doğrulama, formda giriş hataları olduğunda sunucuya gereksiz bir gidiş dönüşten kaçınıyor. Aşağıdaki betik başvuruları _Layout.cshtml ve _ValidationScriptsPartial.cshtml istemci tarafı doğrulamasını destekler:

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.0/jquery.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery-validate/1.19.3/jquery.validate.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery-validation-unobtrusive/3.2.12/jquery.validate.unobtrusive.js"></script>

jQuery Göze Çarpmayan Doğrulama betiği, popüler jQuery Doğrulama eklentisini kullanan özel bir Microsoft ön uç kitaplığıdır. jQuery Göze Çarpmayan Doğrulama olmadan, aynı doğrulama mantığını iki yerde kodlamak zorunda kalırsınız: model özelliklerinde sunucu tarafı doğrulama özniteliklerinde ve ardından istemci tarafı betiklerinde. Bunun yerine, Etiket Yardımcıları ve HTML yardımcıları doğrulama gerektiren form öğeleri için HTML 5 data- özniteliklerini işlemek üzere doğrulama özniteliklerini kullanır ve model özelliklerinden meta verileri yazar. jQuery Göze Çarpmayan Doğrulama, öznitelikleri ayrıştırarak data- mantığı jQuery Doğrulaması'na geçirir ve sunucu tarafı doğrulama mantığını istemciye etkili bir şekilde "kopyalar". Burada gösterildiği gibi etiket yardımcılarını kullanarak istemcide doğrulama hataları görüntüleyebilirsiniz:

<div class="form-group">
    <label asp-for="Movie.ReleaseDate" class="control-label"></label>
    <input asp-for="Movie.ReleaseDate" class="form-control" />
    <span asp-validation-for="Movie.ReleaseDate" class="text-danger"></span>
</div>

Yukarıdaki etiket yardımcıları aşağıdaki HTML'yi işler:

<div class="form-group">
    <label class="control-label" for="Movie_ReleaseDate">Release Date</label>
    <input class="form-control" type="date" data-val="true"
        data-val-required="The Release Date field is required."
        id="Movie_ReleaseDate" name="Movie.ReleaseDate" value="">
    <span class="text-danger field-validation-valid"
        data-valmsg-for="Movie.ReleaseDate" data-valmsg-replace="true"></span>
</div>

HTML çıkışındaki data- öznitelikleri, Movie.ReleaseDate özelliği için doğrulama özniteliklerine karşılık gelir. Özniteliği, data-val-required kullanıcı yayın tarihi alanını doldurmazsa görüntülenecek bir hata iletisi içerir. jQuery Göze Çarpmayan Doğrulama bu değeri jQuery Validation required() yöntemine geçirir ve bu yöntem bu iletiyi eşlik eden <span> öğesinde görüntüler.

Veri türü doğrulaması, [DataType] özniteliği tarafından geçersiz kılınmadığı sürece bir özelliğin .NET türünü temel alır. Tarayıcıların kendi varsayılan hata iletileri vardır, ancak jQuery Doğrulama Engelleyici Olmayan Doğrulama paketi bu iletileri geçersiz kılabilir. [DataType]öznitelikleri ve [EmailAddress] gibi alt sınıflar hata iletisini belirtmenize olanak sağlar.

Göze çarpmayan doğrulama

Engelleyici olmayan doğrulama hakkında bilgi için bu GitHub sorununa bakın.

Dinamik Formlara Doğrulama Ekleme

jQuery Göze Çarpmayan Doğrulama, sayfa ilk yüklendiğinde doğrulama mantığını ve parametrelerini jQuery Doğrulaması'na geçirir. Bu nedenle doğrulama, dinamik olarak oluşturulan formlarda otomatik olarak çalışmaz. Doğrulamayı etkinleştirmek için jQuery Girişim Yapmayan Doğrulama'ya, dinamik formu oluşturduktan hemen sonra ayrıştırmasını söyleyin. Örneğin, aşağıdaki kod AJAX aracılığıyla eklenen bir formda istemci tarafı doğrulamayı ayarlar.

$.get({
    url: "https://url/that/returns/a/form",
    dataType: "html",
    error: function(jqXHR, textStatus, errorThrown) {
        alert(textStatus + ": Couldn't add form. " + errorThrown);
    },
    success: function(newFormHTML) {
        var container = document.getElementById("form-container");
        container.insertAdjacentHTML("beforeend", newFormHTML);
        var forms = container.getElementsByTagName("form");
        var newForm = forms[forms.length - 1];
        $.validator.unobtrusive.parse(newForm);
    }
})

yöntemi, $.validator.unobtrusive.parse() tek bağımsız değişkeni için bir jQuery seçicisi kabul eder. Bu yöntem jQuery Unobtrusive Validation'a bu seçici içindeki data- formların özniteliklerini ayrıştırmalarını söyler. Daha sonra bu özniteliklerin değerleri jQuery Doğrulama eklentisine geçirilir.

Dinamik Denetimlere Doğrulama Ekleme

$.validator.unobtrusive.parse() yöntemi, <input> ve <select/> gibi dinamik olarak tek tek oluşturulan denetimlerde değil, formun bütünü üzerinde çalışır. Formu yeniden ayrıştırmak için, aşağıdaki örnekte gösterildiği gibi, form daha önce ayrıştırıldığında eklenen doğrulama verilerini kaldırın:

$.get({
    url: "https://url/that/returns/a/control",
    dataType: "html",
    error: function(jqXHR, textStatus, errorThrown) {
        alert(textStatus + ": Couldn't add control. " + errorThrown);
    },
    success: function(newInputHTML) {
        var form = document.getElementById("my-form");
        form.insertAdjacentHTML("beforeend", newInputHTML);
        $(form).removeData("validator")    // Added by jQuery Validation
               .removeData("unobtrusiveValidation");   // Added by jQuery Unobtrusive Validation
        $.validator.unobtrusive.parse(form);
    }
})

Özel istemci tarafı doğrulama

Özel istemci tarafı doğrulama, özel bir jQuery Doğrulama bağdaştırıcısıyla çalışan HTML öznitelikleri oluşturularak data- yapılır. Bu makalede daha önce tanıtılan [ClassicMovie] ve [ClassicMovieWithClientValidator] öznitelikleri için aşağıdaki örnek bağdaştırıcı kodu yazılmıştır.

$.validator.addMethod('classicmovie', function (value, element, params) {
    var genre = $(params[0]).val(), year = params[1], date = new Date(value);

    // The Classic genre has a value of '0'.
    if (genre && genre.length > 0 && genre[0] === '0') {
        // The release date for a Classic is valid if it's no greater than the given year.
        return date.getUTCFullYear() <= year;
    }

    return true;
});

$.validator.unobtrusive.adapters.add('classicmovie', ['year'], function (options) {
    var element = $(options.form).find('select#Movie_Genre')[0];

    options.rules['classicmovie'] = [element, parseInt(options.params['year'])];
    options.messages['classicmovie'] = options.message;
});

Bağdaştırıcıları nasıl yazacağınız hakkında bilgi için jQuery Doğrulama belgelerine bkz .

Belirli bir alan için adaptör kullanımı, data- öznitelikleri tarafından tetiklenir.

• Alanı doğrulama için işaretleyin (data-val="true").
• Doğrulama kuralı adını ve hata iletisi metnini (örneğin, data-val-rulename="Error message.") tanımlayın.
• Doğrulayıcının ihtiyaç duyduğu ek parametreleri sağlayın (örneğin, data-val-rulename-param1="value").

Bu örnekte için örnek uygulamanın öznitelikleri gösterilmektedir .

<input class="form-control" type="date"
    data-val="true"
    data-val-classicmovie="Classic movies must have a release year no later than 1960."
    data-val-classicmovie-year="1960"
    data-val-required="The Release Date field is required."
    id="Movie_ReleaseDate" name="Movie.ReleaseDate" value="">

Daha önce belirtildiği gibi, Etiket Yardımcıları ve HTML yardımcıları, data- özelliklerini oluşturmak için doğrulama özelliklerinden elde edilen bilgileri kullanır. Kod yazmak için özel data- HTML özniteliklerinin oluşturulmasına neden olan iki seçenek vardır:

• öğesinden AttributeAdapterBase<TAttribute> türetilen ve öğesini uygulayan IValidationAttributeAdapterProviderbir sınıf oluşturun ve özniteliğinizi ve bağdaştırıcısını DI'ye kaydedin. Bu yöntem, sunucuyla ilgili ve istemciyle ilgili doğrulama kodunun ayrı sınıflarda yer alan tek sorumluluk ilkesini izler. Bağdaştırıcı, DI'ye kayıtlı olduğundan, gerekirse DI'deki diğer hizmetlerin de kullanılabilir olması avantajına da sahiptir.
• IClientModelValidator ögesini ValidationAttribute sınıfınıza uygulayın. Bu yöntem, özniteliği sunucu tarafı doğrulaması yapmıyorsa ve DI'den herhangi bir hizmete ihtiyaç duymadığında uygun olabilir.

İstemci tarafı doğrulaması için AttributeAdapter

HTML'de öznitelikleri işlemenin data- bu yöntemi, ClassicMovie içindeki özniteliği tarafından kullanılır. Bu yöntemi kullanarak istemci doğrulaması eklemek için:

1. Özel doğrulama özniteliği için bir öznitelik bağdaştırıcısı sınıfı oluşturun. AttributeAdapterBase<TAttribute> sınıfından türet. Bu örnekte gösterildiği gibi işlenen çıkışa öznitelik ekleyen AddValidation bir data- yöntem oluşturun:

   public class ClassicMovieAttributeAdapter : AttributeAdapterBase<ClassicMovieAttribute>
   {
       public ClassicMovieAttributeAdapter(
           ClassicMovieAttribute attribute, IStringLocalizer? stringLocalizer)
           : base(attribute, stringLocalizer)
       {
   
       }
   
       public override void AddValidation(ClientModelValidationContext context)
       {
           MergeAttribute(context.Attributes, "data-val", "true");
           MergeAttribute(context.Attributes, "data-val-classicmovie", GetErrorMessage(context));
   
           var year = Attribute.Year.ToString(CultureInfo.InvariantCulture);
           MergeAttribute(context.Attributes, "data-val-classicmovie-year", year);
       }
   
       public override string GetErrorMessage(ModelValidationContextBase validationContext)
           => Attribute.GetErrorMessage();
   }
   

2. IValidationAttributeAdapterProvider implemente eden bir bağdaştırıcı sağlayıcı sınıfı oluşturun. GetAttributeAdapter yönteminde, bu örnekte gösterildiği gibi bağdaştırıcının oluşturucusunun özel özniteliğini geçirin:

   public class CustomValidationAttributeAdapterProvider : IValidationAttributeAdapterProvider
   {
       private readonly IValidationAttributeAdapterProvider baseProvider =
           new ValidationAttributeAdapterProvider();
   
       public IAttributeAdapter? GetAttributeAdapter(
           ValidationAttribute attribute, IStringLocalizer? stringLocalizer)
       {
           if (attribute is ClassicMovieAttribute classicMovieAttribute)
           {
               return new ClassicMovieAttributeAdapter(classicMovieAttribute, stringLocalizer);
           }
   
           return baseProvider.GetAttributeAdapter(attribute, stringLocalizer);
       }
   }
   

3. DI için bağdaştırıcı sağlayıcısını Program.cs kaydedin:

   builder.Services.AddRazorPages()
       .AddMvcOptions(options =>
       {
           options.MaxModelValidationErrors = 50;
           options.ModelBindingMessageProvider.SetValueMustNotBeNullAccessor(
               _ => "The field is required.");
       });
   
   builder.Services.AddSingleton
       <IValidationAttributeAdapterProvider, CustomValidationAttributeAdapterProvider>();
   

İstemci tarafındaki doğrulama için IClientModelValidator

HTML'de öznitelikleri işlemenin data- bu yöntemi, ClassicMovieWithClientValidator içindeki özniteliği tarafından kullanılır. Bu yöntemi kullanarak istemci doğrulaması eklemek için:

• Özel doğrulama özniteliğinde IClientModelValidator arabirimini uygulayın ve bir AddValidation yöntem oluşturun. doğrulama özniteliklerini, aşağıdaki örnekte gösterildiği gibi AddValidation yöntemine ekleyin data-.

  public class ClassicMovieWithClientValidatorAttribute :
      ValidationAttribute, IClientModelValidator
  {
      public ClassicMovieWithClientValidatorAttribute(int year)
          => Year = year;
  
      public int Year { get; }
  
      public void AddValidation(ClientModelValidationContext context)
      {
          MergeAttribute(context.Attributes, "data-val", "true");
          MergeAttribute(context.Attributes, "data-val-classicmovie", GetErrorMessage());
  
          var year = Year.ToString(CultureInfo.InvariantCulture);
          MergeAttribute(context.Attributes, "data-val-classicmovie-year", year);
      }
  
      public string GetErrorMessage() =>
          $"Classic movies must have a release year no later than {Year}.";
  
      protected override ValidationResult? IsValid(
          object? value, ValidationContext validationContext)
      {
          var movie = (Movie)validationContext.ObjectInstance;
          var releaseYear = ((DateTime)value!).Year;
  
          if (movie.Genre == Genre.Classic && releaseYear > Year)
          {
              return new ValidationResult(GetErrorMessage());
          }
  
          return ValidationResult.Success;
      }
  
      private static bool MergeAttribute(IDictionary<string, string> attributes, string key, string value)
      {
          if (attributes.ContainsKey(key))
          {
              return false;
          }
  
          attributes.Add(key, value);
          return true;
      }
  }
  

İstemci tarafı doğrulamayı devre dışı bırakma

Aşağıdaki kod, Sayfalar'da Razor istemci doğrulamasını devre dışı bırakır:

builder.Services.AddRazorPages()
    .AddViewOptions(options =>
    {
        options.HtmlHelperOptions.ClientValidationEnabled = false;
    });

İstemci tarafı doğrulamasını devre dışı bırakmak için diğer seçenekler:

• Tüm _ValidationScriptsPartial dosyalarında .cshtml başvurusunu yorum satırına alın.
• Pages\Shared_ValidationScriptsPartial.cshtml dosyasının içeriğini kaldırın.

Yukarıdaki yaklaşım, ASP.NET Core IdentityRazor sınıf kitaplığının istemci tarafı doğrulamasını engellemez. Daha fazla bilgi için ASP.NET Core projelerinde Scaffold'a bakın.

Sorun ayrıntıları

Sorun Ayrıntıları , HTTP API hatasını açıklayan tek yanıt biçimi değildir, ancak genellikle HTTP API'lerine yönelik hataları bildirmek için kullanılır.

Sorun ayrıntıları hizmeti, ASP.NET Core'da sorun ayrıntıları oluşturmayı destekleyen arabirimini uygular IProblemDetailsService . AddProblemDetails(IServiceCollection) üzerindeki IServiceCollection uzantı yöntemi, varsayılan IProblemDetailsService uygulamayı kaydeder.

ASP.NET Core uygulamalarında, AddProblemDetails çağrıldığında, aşağıdaki ara yazılım, kayıtlı Accept tarafından desteklenen içerik türlerinden birini içermeyen istek HTTP üst bilgisi olduğunda hariç, problem ayrıntıları HTTP yanıtları üretir (varsayılan: ).

• ExceptionHandlerMiddleware: Özel işleyici tanımlanmadığında bir sorun ayrıntıları yanıtı oluşturur.
• StatusCodePagesMiddleware: Varsayılan olarak bir sorun ayrıntıları yanıtı oluşturur.
• DeveloperExceptionPageMiddleware: İstek HTTP üst bilgisinde Accept bulunmadığında, geliştirme aşamasında bir sorun ayrıntıları yanıtı oluşturur.

İlgili içerik

• System.ComponentModel.DataAnnotations
• Model Bağlama
• ASP.NET Core Blazor formlara genel bakış