asp.net-mvc
Datenanmerkungen

Einführung

In ViewModel verwendete grundlegende Validierungsattribute

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

Aussicht

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

Regler

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

Remote-Validierung

Remote Validation wird verwendet, um zu prüfen, ob der in der Eingabesteuerung eingegebene Inhalt gültig ist oder nicht, indem eine Ajax-Anforderung an den Server gesendet wird, um sie zu überprüfen.

Arbeiten

Das RemoteAttribute einen AJAX-Aufruf vom Client an eine Controller-Aktion aus, wobei der Wert des Felds überprüft wird. Die Controller-Aktion gibt dann eine JsonResult Antwort zurück, die angibt, JsonResult die Überprüfung erfolgreich war oder fehlgeschlagen ist. Wenn Sie true von Ihrer Aktion zurückgeben, wird die Überprüfung bestanden. Jeder andere Wert weist auf einen Fehler hin. Wenn Sie false , wird die im Attribut angegebene Fehlermeldung verwendet. Wenn Sie etwas anderes wie einen String oder sogar eine ganze Zahl zurückgeben, wird dies als Fehlermeldung angezeigt. Wenn Ihre Fehlermeldung nicht dynamisch sein soll, ist es sinnvoll, true oder false zurückzugeben, damit der Prüfer die im Attribut angegebene Fehlermeldung verwenden kann.

ViewModel

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

Regler

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

Live-Demo-Geige

Sie können zusätzliche Eigenschaften des Modells mit der AdditionalFields Eigenschaft von RemoteAttribute an die Controller-Methode RemoteAttribute . Ein typisches Szenario besteht darin, die ID-Eigenschaft des Modells in einem 'Edit'-Formular zu übergeben, sodass die Controller-Logik Werte für den vorhandenen Datensatz ignorieren kann.

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

Regler

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

Arbeitsdemo - Zusätzliche Felder

Zusätzliche Anmerkung

Die Standardfehlermeldung ist verständlicherweise vage. RemoteAttribute daher immer daran, die Standardfehlermeldung bei Verwendung des RemoteAttribute .

RequiredAttribute

Das Required Attribut gibt an, dass eine Eigenschaft erforderlich ist. Bei Verwendung der ErrorMessage Eigenschaft für das Attribut kann eine ErrorMessage angegeben werden.

Fügen Sie zuerst den Namespace hinzu:

using System.ComponentModel.DataAnnotations;

Wenden Sie das Attribut auf eine Eigenschaft an.

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

Es ist auch möglich, Ressourcen in der Fehlermeldung für globalisierte Anwendungen zu verwenden. In diesem Fall wird die ErrorMessageResourceName muss mit dem Ressourcenschlüssel der Ressourcenklasse angegeben werden ( resx - Datei) , die auf dem setted muss 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

Das StringLength Attribut gibt die minimale und maximale Länge von Zeichen an, die in einem Datenfeld zulässig sind. Dieses Attribut kann auf Eigenschaften, öffentliche Felder und Parameter angewendet werden. Die ErrorMessage muss in der ErrorMessage Eigenschaft des Attributs angegeben werden. Die Eigenschaften MinimumLength und MaximumLength das Minimum bzw. Maximum an.

Fügen Sie zuerst den Namespace hinzu:

using System.ComponentModel.DataAnnotations;

Wenden Sie das Attribut auf eine Eigenschaft an.

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

Es ist auch möglich, Ressourcen in der Fehlermeldung für globalisierte Anwendungen zu verwenden. In diesem Fall wird die ErrorMessageResourceName muss mit dem Ressourcenschlüssel der Ressourcenklasse angegeben werden ( resx - Datei) , die auf dem setted muss 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; }
}

Bereichsattribut

Das Range Attribut kann beliebige Eigenschaften oder öffentliche Felder dekorieren und gibt einen Bereich an, zwischen dem ein numerisches Feld liegen muss, um als gültig zu gelten.

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

Darüber hinaus akzeptiert es eine optionale ErrorMessage Eigenschaft, mit der die vom Benutzer empfangene Nachricht festgelegt werden kann, wenn ungültige Daten eingegeben werden:

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

Beispiel

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

RegularExpression-Attribut

Das Attribut [RegularExpression] kann beliebige Eigenschaften oder öffentliche Felder schmücken und gibt einen regulären Ausdruck an, der abgeglichen werden muss, damit die Eigenschaft als gültig gilt.

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

Darüber hinaus akzeptiert es eine optionale ErrorMessage Eigenschaft, mit der die vom Benutzer empfangene Nachricht festgelegt werden kann, wenn ungültige Daten eingegeben werden:

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

Beispiel (e)

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

Attribut vergleichen

Das Compare Attribut vergleicht zwei Eigenschaften eines Modells.

Die Fehlermeldung kann mit der Eigenschaft ErrorMessage oder mit Ressourcendateien angegeben werden.

So verwenden Sie den Compare Attribut enthält using für den folgenden Namespace:

using System.ComponentModel.DataAnnotations;

Dann können Sie das Attribut in Ihrem Modell verwenden:

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

Wenn dieses Modell validiert ist und die Werte für Email und ConfirmEmail unterschiedliche Werte haben, ConfirmEmail die Validierung fehl.

Lokalisierte Fehlermeldungen

Wie bei allen Validierungsattributen können Fehlermeldungen aus Ressourcendateien verwendet werden. In diesem Beispiel wird die Fehlermeldung aus der Ressourcendatei Resources geladen. Der Ressourcenname lautet CompareValidationMessage :

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

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

Vermeiden Sie Zeichenfolgen in Eigenschaftsnamen

Mit String für Eigenschaftswert in C # zu vermeiden 6+ Sie verwenden können nameof Stichwort:

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

Platzhalter in Fehlermeldungen

Sie können in Ihren Fehlermeldungen Platzhalter verwenden. Der Platzhalter {0} wird durch den Anzeigenamen der aktuellen Eigenschaft und {1} durch den Anzeigenamen der zugehörigen Eigenschaft ersetzt:

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

Wenn die Validierung des Modells fehlschlägt, wird die Fehlermeldung angezeigt

Die Felder "E-Mail" und "E-Mail bestätigen" stimmen nicht überein.

Benutzerdefiniertes Validierungsattribut

Wenn Sie einige Regeln validieren möchten, bei denen es sich nicht um eine generische Datenvalidierung handelt, z. B. um sicherzustellen, dass ein Feld erforderlich ist oder einen Wertebereich, die jedoch für Ihre Geschäftslogik spezifisch sind, können Sie Ihren eigenen benutzerdefinierten Validator erstellen. Um ein benutzerdefiniertes Validierungsattribut zu erstellen, müssen Sie nur inherit ValidationAttribute Klasse inherit und override IsValid Methode override . Die IsValid Methode nimmt zwei Parameter an. Der erste ist ein object Namen value und der zweite ein ValidationContext object Namen validationContext . Value bezieht sich auf den tatsächlichen Wert aus dem Feld, das Ihr benutzerdefinierter Prüfer überprüfen wird.

Angenommen, Sie möchten die Email über den 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 ist seine DotNetFiddle-Demo

EDMx-Modell - Datenanmerkung

Edmx-Modell Internel

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

Hinzufügen von Datenanmerkungen dazu - Wenn wir dieses Modell direkt ändern, gehen die Änderungen bei einer Aktualisierung des Modells verloren. so

Hinzufügen eines Attributs in diesem Fall 'Erforderlich'

Neue Klasse erstellen - beliebiger Name Dann

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

        //...
    }
}

oder

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

Datenanmerkungen für die Datenbankimplementierung (Modellcode wird automatisch generiert)

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

Wenn Sie die Datenbank zuerst verwendet haben und Ihr Modellcode automatisch generiert wurde, wird diese Meldung über Ihrem Modellcode angezeigt:

Dieser Code wurde aus einer Vorlage generiert. Manuelle Änderungen an dieser Datei können zu unerwartetem Verhalten in Ihrer Anwendung führen. Manuelle Änderungen an dieser Datei werden überschrieben, wenn der Code neu generiert wird

Wenn Sie Datenanmerkungen verwenden möchten und diese nicht überschrieben werden sollen, wenn Sie den edmx aktualisieren, fügen Sie dem Modellordner einfach eine weitere Teilklasse hinzu, die dem obigen Beispiel entspricht.