asp.net-mvc
Gegevensaantekeningen

Invoering

Fundamentele validatiekenmerken die in ViewModel worden gebruikt

Model

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

Visie

// 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" />
}

controleur

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

Externe validatie

Externe validatie wordt gebruikt om te controleren of de inhoud die is ingevoerd in het invoerbesturingselement geldig is of niet, door een ajax-verzoek naar de server te verzenden om het te controleren.

Werken

De RemoteAttribute werkt door een AJAX-oproep van de client naar een controlleractie uit te voeren met de waarde van het veld dat wordt gevalideerd. De controlleractie retourneert vervolgens een JsonResult reactie die aangeeft of de validatie is geslaagd of mislukt. Als u true terugkeert van uw actie, geeft dit aan dat de validatie is geslaagd. Elke andere waarde duidt op een storing. Als u false retourneert, wordt het foutbericht gebruikt dat is opgegeven in het kenmerk. Als u iets anders retourneert, zoals een tekenreeks of zelfs een geheel getal, wordt dit weergegeven als het foutbericht. Tenzij u uw foutbericht dynamisch wilt hebben, is het logisch om waar of onwaar terug te geven en de validator het foutbericht te laten gebruiken dat in het kenmerk is opgegeven.

ViewModel

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

controleur

[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

U kunt aanvullende eigenschappen van het model doorgeven aan de controllermethode met behulp van de eigenschap AdditionalFields van RemoteAttribute . Een typisch scenario zou zijn om de ID-eigenschap van het model door te geven in de vorm 'Bewerken', zodat de logica van de controller waarden voor het bestaande record kan negeren.

Model

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

controleur

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

Werkdemo - Extra velden

Aanvullende opmerking

Het standaardfoutbericht is begrijpelijkerwijs vaag, dus vergeet niet om het standaardfoutbericht te negeren wanneer u het RemoteAttribute .

RequiredAttribute

Het kenmerk Required geeft aan dat een eigenschap vereist is. Er kan een foutbericht worden opgegeven bij het gebruik van de eigenschap ErrorMessage op het kenmerk.

Voeg eerst de naamruimte toe:

using System.ComponentModel.DataAnnotations;

En pas het kenmerk toe op een eigenschap.

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

Het is ook mogelijk om bronnen in het foutbericht te gebruiken voor geglobaliseerde toepassingen. In dit geval moet de ErrorMessageResourceName worden opgegeven met de ErrorMessageResourceName van de resx ( resx bestand) die moet worden ingesteld op het 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

Het kenmerk StringLength geeft de minimale en maximale lengte van tekens aan die zijn toegestaan in een gegevensveld. Dit kenmerk kan worden toegepast op eigenschappen, openbare velden en parameters. Het foutbericht moet worden opgegeven in de eigenschap ErrorMessage op het kenmerk. De eigenschappen MinimumLength en MaximumLength respectievelijk het minimum en maximum aan.

Voeg eerst de naamruimte toe:

using System.ComponentModel.DataAnnotations;

En pas het kenmerk toe op een eigenschap.

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

Het is ook mogelijk om bronnen in het foutbericht te gebruiken voor geglobaliseerde toepassingen. In dit geval moet de ErrorMessageResourceName worden opgegeven met de ErrorMessageResourceName van de resx ( resx bestand) die moet worden ingesteld op het 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; }
}

Bereikkenmerk

Het Range kan alle eigenschappen of openbare velden versieren en geeft een bereik aan waar een numeriek veld tussen moet vallen om als geldig te worden beschouwd.

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

Bovendien accepteert het een optionele eigenschap ErrorMessage die kan worden gebruikt om het bericht in te stellen dat de gebruiker ontvangt wanneer ongeldige gegevens worden ingevoerd:

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

Voorbeeld

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

RegularExpression-kenmerk

Het attribuut [RegularExpression] kan alle eigenschappen of openbare velden versieren en geeft een reguliere expressie aan die moet worden gevonden om de eigenschap als geldig te kunnen beschouwen.

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

Bovendien accepteert het een optionele eigenschap ErrorMessage die kan worden gebruikt om het bericht in te stellen dat de gebruiker ontvangt wanneer ongeldige gegevens worden ingevoerd:

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

Voorbeeld (en)

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

Attribuut vergelijken

Het kenmerk Compare vergelijkt twee eigenschappen van een model.

Het foutbericht kan worden opgegeven met de eigenschap ErrorMessage of met behulp van bronbestanden.

Om het kenmerk Compare te gebruiken, moet using de volgende naamruimte gebruiken:

using System.ComponentModel.DataAnnotations;

Vervolgens kunt u het kenmerk in uw model gebruiken:

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

Wanneer dit model valideert en de Email en ConfirmEmail verschillende waarden hebben, zal de validatie mislukken.

Gelokaliseerde foutmeldingen

Net als bij alle validatiekenmerken is het mogelijk om foutmeldingen uit bronbestanden te gebruiken. In dit voorbeeld wordt een foutmelding van resource file worden geladen Resources , naam van de bron is CompareValidationMessage :

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

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

Vermijd tekenreeksen in eigenschapsnamen

Om te voorkomen dat string als eigenschapswaarde wordt gebruikt, kunt u in C # 6+ de nameof trefwoord gebruiken:

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

Plaatshouders in foutmeldingen

U kunt tijdelijke aanduidingen gebruiken in uw foutmeldingen. Plaatshouder {0} wordt vervangen door de weergavenaam van de huidige eigenschap en {1} wordt vervangen door de weergavenaam van gerelateerde eigenschap:

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

Als de validatie van het model mislukt, wordt het foutbericht weergegeven

De velden 'E-mail' en 'E-mail bevestigen' komen niet overeen.

Aangepast validatiekenmerk

Als het gaat om het valideren van enkele regels die geen generieke gegevensvalidatie zijn, bijv. Ervoor zorgen dat een veld is vereist of een reeks waarden, maar ze zijn specifiek voor uw bedrijfslogica, kunt u uw eigen aangepaste validator maken . Als u een aangepaste validatie attribuut te maken, je hoeft alleen maar te inherit ValidationAttribute klasse en override haar IsValid methode. De IsValid methode heeft twee parameters, de eerste is een object naam value en de tweede is een ValidationContext object naam validationContext . Value verwijst naar de werkelijke waarde uit het veld dat uw aangepaste validator gaat valideren.

Stel dat u Email wilt valideren 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; }
}

Hier is de DotNetFiddle-demo

EDMx-model - gegevensaantekening

Edmx model internel

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

Hieraan worden gegevensannotaties toegevoegd: als we dit model rechtstreeks wijzigen, gaan de wijzigingen verloren wanneer een update van het model wordt aangebracht. zo

Om in dit geval een attribuut toe te voegen 'Verplicht'

Maak een nieuwe klasse - elke naam dan

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

        //...
    }
}

of

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 */
    }
}

Gegevensaantekeningen voor eerste implementatie van database (automatisch gegenereerde modelcode)

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

Als u eerst database-database hebt gebruikt en uw modelcode automatisch is gegenereerd, verschijnt dit bericht boven uw modelcode:

Deze code is gegenereerd op basis van een sjabloon. Handmatige wijzigingen in dit bestand kunnen onverwacht gedrag in uw toepassing veroorzaken. Handmatige wijzigingen in dit bestand worden overschreven als de code opnieuw wordt gegenereerd

Als u gegevensannotaties wilt gebruiken en niet wilt dat ze worden overschreven als u de edmx vernieuwt, voegt u gewoon een andere gedeeltelijke klasse toe aan uw modelmap die eruit ziet als het bovenstaande voorbeeld.