asp.net-mvc
Dataanmärkningar

Introduktion

Grundläggande valideringsattribut som används i ViewModel

Modell

using System.ComponentModel.DataAnnotations;

public class ViewModel
{
    [Required(ErrorMessage="Name is required")] 
    public string Name { get; set; }

    [StringLength(14, MinimumLength = 14, ErrorMessage = "Invalid Phone Number")]
    [Required(ErrorMessage="Phone Number is required")] 
    public string PhoneNo { get; set; }

    [Range(typeof(decimal), "0", "150")]
    public decimal? Age { get; set; }

    [RegularExpression(@"^\d{5}(-\d{4})?$", ErrorMessage = "Invalid Zip Code.")]
    public string ZipCode {get;set;}

    [EmailAddress(ErrorMessage = "Invalid Email Address")] 
    public string Email { get; set; }

    [Editable(false)] 
    public string Address{ get; set; }
}

Se

// Include Jquery and Unobstructive Js here for client side validation

@using (Html.BeginForm("Index","Home") { 

    @Html.TextBoxFor(model => model.Name) 
    @Html.ValidationMessageFor(model => model.Name)

    @Html.TextBoxFor(model => model.PhoneNo)
    @Html.ValidationMessageFor(model => model.PhoneNo)

    @Html.TextBoxFor(model => model.Age)
    @Html.ValidationMessageFor(model => model.Age)

    @Html.TextBoxFor(model => model.ZipCode)
    @Html.ValidationMessageFor(model => model.ZipCode)

    @Html.TextBoxFor(model => model.Email)
    @Html.ValidationMessageFor(model => model.Email)

    @Html.TextBoxFor(model => model.Address)
    @Html.ValidationMessageFor(model => model.Address)

    <input type="submit" value="submit" />
}

Kontrollant

public ActionResult Index(ViewModel _Model) 
{ 
    // Checking whether the Form posted is valid one. 
    if(ModelState.IsValid) 
    { 
        // your model is valid here.
        // perform any actions you need to, like database actions,
        // and/or redirecting to other controllers and actions.
    }
    else 
    {
        // redirect to same action
        return View(_Model);
    } 
}

Fjärrvalidering

Fjärrvalidering används för att kontrollera om innehållet i ingångskontrollen är giltigt eller inte genom att skicka en ajax-begäran till serversidan för att kontrollera det.

Arbetssätt

RemoteAttribute fungerar genom att ringa ett AJAX-samtal från klienten till en controlleråtgärd med fältets värde som valideras. Controlleråtgärden returnerar sedan ett JsonResult svar som indikerar valideringsframgång eller misslyckande. Returnera true från din åtgärd indikerar att validering passerat. Alla andra värden indikerar fel. Om du returnerar false används felmeddelandet som anges i attributet. Om du returnerar något annat, t.ex. en sträng eller till och med ett heltal, kommer det att visas som felmeddelandet. Om du inte vill att ditt felmeddelande ska vara dynamiskt är det vettigt att returnera sant eller falskt och låta valideraren använda felmeddelandet som anges i attributet.

Viewmodel

public class ViewModel
{
    [Remote("IsEmailAvailable", "Group", HttpMethod = "POST", ErrorMessage = "Email already exists. Please enter a different email address.")]
    public string Email{ get; set; }
}

Kontrollant

[HttpPost]
public JsonResult IsEmailAvailable(string Email)
{
    // Logic to check whether email is already registered or Not.
    var emailExists = IsEmailRegistered();
    return Json(!emailExists);         
} 

Live Demo Fiddle

Du kan passera ytterligare egenskaper hos modellen till styrenheten metod med användning av AdditionalFields egendom RemoteAttribute . Ett typiskt scenario skulle vara att överföra ID-egenskapen för modellen i en "Redigera" -form, så att kontrollerlogiken kan ignorera värden för den befintliga posten.

Modell

  public int? ID { get; set; }
  [Display(Name = "Email address")]
  [DataType(DataType.EmailAddress)]
  [Required(ErrorMessage = "Please enter you email address")]
  [Remote("IsEmailAvailable", HttpMethod="Post", AdditionalFields="ID", ErrorMessage = "Email already exists. Please enter a different email address.")]  
  public string Email { get; set; }

Kontrollant

[HttpPost]
public ActionResult Validate(string email, int? id)
{
    if (id.HasValue)
    {
        return Json(!db.Users.Any(x => x.Email == email && x.ID != id);
    }
    else
    {
        return Json(!db.Users.Any(x => x.Email == email);
    }
}

Working Demo - Ytterligare fält

Ytterligare anmärkning

Standardfelmeddelandet är förståeligt vagt, så kom alltid ihåg att åsidosätta standardfelmeddelandet när du använder RemoteAttribute .

RequiredAttribute

Attributet Required anger att en egenskap krävs. Ett felmeddelande kan anges ErrorMessage egenskapen ErrorMessage i attributet.

Lägg först till namnområdet:

using System.ComponentModel.DataAnnotations;

Och tillämpa attributet på en fastighet.

public class Product
{
   [Required(ErrorMessage = "The product name is required.")]
   public string Name { get; set; }

   [Required(ErrorMessage = "The product description is required.")]
   public string Description { get; set; }
}

Det är också möjligt att använda resurser i felmeddelandet för globaliserade applikationer. I detta fall måste ErrorMessageResourceName anges med resx ( resx filen) som måste ställas in på ErrorMessageResourceType :

public class Product
{
   [Required(ErrorMessageResourceName = "ProductNameRequired", 
             ErrorMessageResourceType = typeof(ResourceClass))]
   public string Name { get; set; }

   [Required(ErrorMessageResourceName = "ProductDescriptionRequired", 
             ErrorMessageResourceType = typeof(ResourceClass))]
   public string Description { get; set; }
}

StringLengthAttribute

StringLength attributet anger minimi- och maxlängden för tecken som är tillåtna i ett datafält. Detta attribut kan tillämpas på egenskaper, offentliga fält och parametrar. Felmeddelandet måste anges i egenskapen ErrorMessage på attributet. Egenskaperna MinimumLength och MaximumLength anger respektive MaximumLength och maxlängd.

Lägg först till namnområdet:

using System.ComponentModel.DataAnnotations;

Och tillämpa attributet på en fastighet.

public class User
{
   // set the maximum
   [StringLength(20, ErrorMessage = "The username cannot exceed 20 characters. ")]
   public string Username { get; set; }

   [StringLength(MinimumLength = 3, MaximumLength = 16, ErrorMessage = "The password must have between 3 and 16 characters.")]        
   public string Password { get; set; }
}

Det är också möjligt att använda resurser i felmeddelandet för globaliserade applikationer. I detta fall måste ErrorMessageResourceName anges med resx ( resx filen) som måste ställas in på ErrorMessageResourceType :

public class User
{
   [StringLength(20, ErrorMessageResourceName = "StringLength", 
                              ErrorMessageResourceType = typeof(ResoucesKeys))]        
   public string Username { get; set; }

   [StringLength(MinimumLength = 3, 
                        MaximumLength = 16, 
                        ErrorMessageResourceName = "StringLength", 
                        ErrorMessageResourceType = typeof(ResoucesKeys))]        
   public string Password { get; set; }
}

Range Attribut

Range attributet kan dekorera alla egenskaper eller offentliga fält och anger ett intervall som ett numeriskt fält måste falla mellan för att anses vara giltigt.

[Range(minimumValue, maximumValue)]
public int Property { get; set; }

Dessutom accepterar den en valfri egenskap ErrorMessage som kan användas för att ställa in meddelandet som mottagits av användaren när ogiltig data anges:

[Range(minimumValue, maximumValue, ErrorMessage = "{your-error-message}")]
public int Property { get; set; }

Exempel

[Range(1,100, ErrorMessage = "Ranking must be between 1 and 100.")]
public int Ranking { get; set; }

RegularExpression Attribut

[RegularExpression] kan dekorera alla egenskaper eller offentliga fält och anger ett regelbundet uttryck som måste matchas för egenskapen anses vara giltig.

[RegularExpression(validationExpression)]
public string Property { get; set; }

Dessutom accepterar den en valfri egenskap ErrorMessage som kan användas för att ställa in meddelandet som mottagits av användaren när ogiltig data anges:

[RegularExpression(validationExpression, ErrorMessage = "{your-error-message}")]
public string Property { get; set; }

Exempel (s)

[RegularExpression(@"^[a-z]{8,16}?$", ErrorMessage = "A User Name must consist of 8-16 lowercase letters")]
public string UserName{ get; set; }
[RegularExpression(@"^\d{5}(-\d{4})?$", ErrorMessage = "Please enter a valid ZIP Code (e.g. 12345, 12345-1234)")]
public string ZipCode { get; set; }

Jämför attribut

Attributet Compare jämför två egenskaper hos en modell.

Felmeddelandet kan specificeras med egenskapen ErrorMessage eller med resursfiler.

För att använda Compare attribut inkluderar du using för följande namnutrymme:

using System.ComponentModel.DataAnnotations;

Sedan kan du använda attributet i din modell:

public class RegisterModel
{
    public string Email { get; set; }

    [Compare("Email",  ErrorMessage = "The Email and Confirm Email fields do not match.")]
    public string ConfirmEmail { get; set; }
}

När den här modellen valideras, om Email och ConfirmEmail har olika värden, kommer valideringen att misslyckas.

Lokaliserade felmeddelanden

Precis som med alla valideringsattribut är det möjligt att använda felmeddelanden från resursfiler. I detta prov felmeddelandet laddas från resursfilen Resources är resursnamnet CompareValidationMessage :

public class RegisterModel
{
    public string Email { get; set; }

    ["Email", ErrorMessageResourceType = typeof(Resources),  ErrorMessageResourceName = "CompareValidationMessage")]
    public string ConfirmEmail { get; set; }
}

Undvik strängar i egendomens namn

För att undvika att använda sträng för fastighetsvärde kan du i C # 6+ använda nameof nyckelord:

public class RegisterModel
{
    public string Email { get; set; }

    [Compare(nameof(Email),  ErrorMessage = "The Email and Confirm Email fields do not match.")]
    public string ConfirmEmail { get; set; }
}

Platshållare i felmeddelanden

Du kan använda platshållare i dina felmeddelanden. Platshållare {0} ersätts med visningsnamnet för aktuell egendom och {1} ersätts med visningsnamn för relaterad egenskap:

public class RegisterModel
{
    [Display(Name = "Email")]
    public string Email { get; set; }

    [Display(Name = "Confirm Email")]
    [Compare("Email",  ErrorMessage = "The '{1}' and '{0}' fields do not match.")]
    public string ConfirmEmail { get; set; }
}

Om validering av modellen misslyckas kommer felmeddelandet att vara

Fälten "E-post" och "Bekräfta e-post" matchar inte.

Anpassat valideringsattribut

När det gäller att validera vissa regler som inte är generisk datavalidering, t.ex. att säkerställa att ett fält krävs eller ett antal värden, men de är specifika för din affärslogik, kan du skapa din egen anpassade validerare . För att skapa ett anpassat valideringsattribut behöver du bara inherit ValidationAttribute klassen och override IsValid metoden. IsValid metoden tar två parametrar, det första är ett object heter som value och det andra är ett ValidationContext object heter validationContext . Value hänvisar till det verkliga värdet från fältet som din anpassade validerare kommer att validera.

Anta att du vill validera Email via Custom Validator

public class MyCustomValidator : ValidationAttribute
{
    private static string myEmail= "[email protected]";

    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        string Email = value.ToString();
        if(myEmail.Equals(Email))
            return new ValidationResult("Email Already Exist");
        return ValidationResult.Success;
    }
}

public class SampleViewModel
{
    [MyCustomValidator]
    [Required]
    public string Email { get; set; }

    public string Name { get; set; }
}

Här är dess DotNetFiddle-demo

EDMx-modell - Data Annotation

Edmx modell intern

public partial class ItemRequest
{
    public int RequestId { get; set; }
    //...
}

Lägga till en kommentar till detta - om vi modifierar den här modellen direkt, när en uppdatering till modellen görs, förloras ändringarna. så

Lägga till ett attribut i det här fallet "Obligatoriskt"

Skapa en ny klass - vilket namn som helst sedan

using System.ComponentModel;
using System.ComponentModel.DataAnnotations;

//make sure the namespace is equal to the other partial class ItemRequest
namespace MvcApplication1.Models 
{
    [MetadataType(typeof(ItemRequestMetaData))]
    public partial class ItemRequest
    {
    }

    public class ItemRequestMetaData
    {
        [Required]
        public int RequestId {get;set;}

        //...
    }
}

eller

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace YourApplication.Models
{
    public interface IEntityMetadata
    {
        [Required]
        Int32 Id { get; set; }
    }

    [MetadataType(typeof(IEntityMetadata))]
    public partial class Entity : IEntityMetadata
    {
        /* Id property has already existed in the mapped class */
    }
}

Dataanmärkningar för första implementeringen av databasen (modellkod auto-genererad)

[MetadataType(typeof(RoleMetaData))]
public partial class ROLE
{
}

public class RoleMetaData
{
    [Display(Name = "Role")]
    public string ROLE_DESCRIPTION { get; set; }

    [Display(Name = "Username")]
    public string ROLE_USERNAME { get; set; }
}

Om du använde databas först och din modellkod genererades automatiskt visas detta meddelande ovanför din modellkod:

Den här koden genererades från en mall. Manuella ändringar av den här filen kan orsaka oväntat beteende i din applikation. Manuella ändringar av den här filen skrivs över om koden regenereras

Om du vill använda dataanmärkningar och inte vill att de ska skrivas över om du uppdaterar edmx, lägg till ytterligare en delklass i din modellmapp som ser ut som exemplet ovan.