Meilleure pratique de validation pour Model et ViewModel

Je n'ai séparé modèle et classes viewmodel. Où les classes viewmodel seulement niveau de l'INTERFACE utilisateur de validation (voir: Validation: Modèle ou ViewModel).

Je peux vérifier sur le post de l'action dans un contrôleur de modèle (vewmodel) est valide.

Le demander:
Comment puis-je valider le modèle (la principale entité d'annotation de données).

Je ne suis pas le développement de ce dernier à l'aide du modèle objet. Un peu double emploi avec les propriétés et l'ajout de toutes les propriétés, éventuellement requis dans ce point de vue particulier.

//Model Class
public class User
{
    [Required]
    public string Email {get; set;}

    [Required]
    public DateTime Created {get; set;}
}

//ViewModel Class
public class UserViewModel
{
    [Required]
    public string Email {get; set;}

    [Required]
    public string LivesIn {get; set;}
}

//Post action
public ActionResult(UserViewModel uvm)
{
    if( ModelState.IsValid)
        //means user entered data correctly and is validated

    User u = new User() {Email = uvm.Email, Created = DateTime.Now};
    //How do I validate "u"?

    return View();
}

Doit faire quelque chose comme ceci:

var results = new List<ValidationResult>();
var context = new ValidationContext(u, null, null);
var r = Validator.TryValidateObject(u, context, results);

Ce que je pense est l'ajout de cette technique de validation dans la classe de base (de l'entité d'affaires), et de vérifier quand je suis à la cartographie de l'viewmodel de la classe d'entité commerciale.

Des suggestions?

source d'informationauteur Yahya

  1. 9

    1) Utiliser couramment la validation sur le modèle de la récupère les informations de l'utilisateur. il est plus souple puis annotation de données et plus facile à tester.

    2) Vous voudrez peut-être regarder dans automapper, en utilisant automapper vous n'avez pas à écrire x.name = y.name.

    3) Pour votre modèle de base de données je m'en tiendrais aux données-les annotations.

    Tout ci-dessous est basé sur les nouvelles informations

    Première et tout ce que vous devez placer validation à la fois, comme vous l'avez fait maintenant pour la validation du modèle c'est la façon dont je le ferais. Avertissement: ce n'est pas la meilleure façon

    Première et toutes les mise à jour de la UserViewModel à

    public class UserViewModel
    {
        [Required()]
        [RegularExpression(@"^(([A-Za-z0-9]+_+)|([A-Za-z0-9]+\-+)|([A-Za-z0-9]+\.+)|([A-Za-z0-9]+\++))*[A-Za-z0-9]+@((\w+\-+)|(\w+\.))*\w{1,63}\.[a-zA-Z]{2,6}$")]
        public String Email { get; set; }
    }

    Puis mise à jour de la méthode d'action pour 

            //Post action
        [HttpPost]
        public ActionResult register (UserViewModel uvm)
        {
            //This validates the UserViewModel
            if (ModelState.IsValid)
            {

                try
                {
                    //You should delegate this task to a service but to keep it simple we do it here
                    User u = new User() { Email = uvm.Email, Created = DateTime.Now };
                    RedirectToAction("Index"); //On success you go to other page right?
                }
                catch (Exception x)
                {
                    ModelState.AddModelError("RegistrationError", x); //Replace x with your error message
                }

            }       

            //Return your UserViewModel to the view if something happened               
            return View(uvm);
        }

    Maintenant pour le modèle de l'utilisateur ce qui est difficile et vous avez de nombreuses solutions possibles. La solution que j'ai trouvé (sans doute pas la meilleure) est la suivante:

    public class User
    {
        private string email;
        private DateTime created;

        public string Email
        {
            get
            {
                return email;
            }
            set
            {
                email = ValidateEmail(value);
            }
        }

        private string ValidateEmail(string value)
        {
            if (!validEmail(value))
                throw new NotSupportedException("Not a valid email address");     

            return value;
        }

        private bool validEmail(string value)
        {
            return Regex.IsMatch(value, @"^(([A-Za-z0-9]+_+)|([A-Za-z0-9]+\-+)|([A-Za-z0-9]+\.+)|([A-Za-z0-9]+\++))*[A-Za-z0-9]+@((\w+\-+)|(\w+\.))*\w{1,63}\.[a-zA-Z]{2,6}$");
        }

    Dernier une unité de test pour vérifier mon propre code: 

       [TestClass()]
    public class UserTest
    {

        ///<summary>
        ///If the email is valid it is stored in the private container
        ///</summary>
        [TestMethod()]
        public void UserEmailGetsValidated()
        {
            User x = new User();
            x.Email = "[email protected]";
            Assert.AreEqual("[email protected]", x.Email);
        }

        ///<summary>
        ///If the email is invalid it is not stored and an error is thrown in this application
        ///</summary>
        [TestMethod()]
        [ExpectedException(typeof(NotSupportedException))]
        public void UserEmailPropertyThrowsErrorWhenInvalidEmail()    
       {
           User x = new User();
           x.Email = "blah blah blah";
           Assert.AreNotEqual("blah blah blah", x.Email);
       }


        ///<summary>
        ///Clears an assumption that on object creation the email is validated when its set
        ///</summary>
        [TestMethod()]
        public void UserGetsValidatedOnConstructionOfObject()
        {
            User x = new User() { Email = "[email protected]" };
            x.Email = "[email protected]";
            Assert.AreEqual("[email protected]", x.Email);
        }
    }
  2. 2

    Je pense que c'est mieux d'utiliser des Annotations de Données
    regardez cette

    ASP.NET MVC Valdation

    et pour la validation côté serveur, vous pouvez utiliser le couramment validation

    et de regarder ce question