MVC- Custom Data Annotations validation server and client side

How to validate model in MVC?

Validation is most important part in any website which allows entering information.

Now, question is what is the easiest way to implement validation on MVC application?

Fortunately MVC provide a great facility for implement data validation using DataAnnotation.

I hope now day all are aware about of data annotation and attribute pattern for code, If you not aware then please do quick google for that.

In C# using data annotation we can validate our model using validation attributes

Need to add Data Annotation DLL: System.ComponentModel.DataAnnotations

It is inbuilt providing some validation attributes like required, string length etc..

In MVC we are prefer to working by model and we can validate model using data annotation class.

Example:

           public class TestModel2
            {
                public int Id { get; set; }
                [Required(ErrorMessage = "Name is Required")]
                public string Name { get; set; }
                [Required(ErrorMessage = "Email is Required")]
                [RegularExpression(@"^[\w\.=-]+@[\w\.-]+\.[\w]{2,3}$",
                     ErrorMessage = "Please enter valid email")]
                public string Email { get; set; }
                [StringLength(300)]
                public string Description { get; set; }
                [Compare("Email", ErrorMessage = 
                    "User name should be email id")]
                public string Username { get; set; }
                public DateTime PlanStratDate { get; set; }
                public DateTime PlanEndDate { get; set; }
                public string ExternalId { get; set; }
            }

           

We can validate model in both way at server side and also at client site.

For validation at client side we need to do some setting in web.config file.

In MVC 3 and onward that setting comes by default if u create project from internet website template.

MVC providing jquery.validate.js and [jquery.validate.unobtrusive.js for client side validation.

For more details about unobtrusive.js please refer blog : http://bradwilson.typepad.com/blog/2010/10/mvc3-unobtrusive-validation.html

In web.config file we need to add


Using built in validation attributes we covered almost every scenario. But in some case we need out of box validation.

For out of box validation we can create custom validation attributes and set on model.

Example:

       
        public class TestModel2
            {
                public int Id { get; set; }
                [Required(ErrorMessage = "Name is Required")]
                public string Name { get; set; }
                [Required(ErrorMessage = "Email is Required")]
                [RegularExpression(@"^[\w\.=-]+@[\w\.-]+\.[\w]{2,3}$", 
                ErrorMessage = "Please enter valid email")]
                public string Email { get; set; }
                [StringLength(300)]
                public string Description { get; set; }
                [Compare("Email", ErrorMessage =
                "User name should be email id")]
                public string Username { get; set; }
                public DateTime PlanStratDate { get; set; }
                [GratherThen("PlanStratDate")]
                public DateTime PlanEndDate { get; set; }
                [ExternalIdPattern]
                public string ExternalId { get; set; }
            }

        

First we need to create custom validation class and inherit from Validation Attribute class

After that need to implement one IsValidate override method and add your custom validation code in this method.

That's all almost done Now server side validation working for model.

Validation Class:

       public class ExternalIdPatternAttribute : ValidationAttribute , IClientValidatable
        {
            public ExternalIdPatternAttribute() : 
            base("External id should be match with system pattern") { }

            public override bool IsValid(object value)
            {
                const string matchingPattern = "code4help";
                return Convert.ToString(value).Contains(matchingPattern);
            }

            public IEnumerable[ModelClientValidationRule] GetClientValidationRules
            (ModelMetadata metadata, ControllerContext context)
                {
                   var errorMessage = ErrorMessageString;
                    var extidrule = new ModelClientValidationRule();
                    extidrule.ErrorMessage = errorMessage;
                    extidrule.ValidationType = "externalidpattern";
                    //extidrule.ValidationParameters.Add("otherpropertyname",
                         otherPropertyName);

                    yield return extidrule;
                }
         }


                
                


        public class GratherThenAttribute : ValidationAttribute , IClientValidatable
            {
                public string OtherProperty { get; set; }

                public GratherThenAttribute(string oprop)
                    : base("{0} should be grather then {1}")
                {
                    this.OtherProperty = oprop;
                }

                protected override ValidationResult IsValid(object value,
                 ValidationContext validationContext)
                {
                    var validationResult = ValidationResult.Success;
                    var otherPropertyval = 
                    validationContext.ObjectType.GetProperty(this.OtherProperty);
                    if (otherPropertyval.PropertyType == new DateTime().GetType())
                    {
                        var edate = (DateTime)value;
                        var sdate = 
                        (DateTime)otherPropertyval.GetValue(validationContext.ObjectInstance,
                         null);

                        if (edate.CompareTo(sdate) < 1)
                            validationResult = new ValidationResult(ErrorMessageString);
                    }
                    else
                        validationResult =
                            new ValidationResult(
                                "An error occurred while validating the property.
                                 OtherProperty is not of type DateTime");
                    return validationResult;
                }

                public IEnumerable[ModelClientValidationRule] 
                    GetClientValidationRules(ModelMetadata metadata, 
                    ControllerContext context)
                        {
                            var errorMessage = ErrorMessageString;

                            var extidrule = new ModelClientValidationRule();
                            extidrule.ErrorMessage = errorMessage;
                            extidrule.ValidationType = "gratherthen";
                            extidrule.ValidationParameters.Add("otherproperty", OtherProperty);

                            yield return extidrule;
                        }
                    }

            

For client side validation we need to implement IClientValidatable interface on custom validation class and get validation rule.

In validation rule validation type and all parameter should be in small case.

Now for start validation on client side we need to add custom javascript in unobtrusive script.

Code for custom validation client side:

            $.validator.addMethod("externalidpattern", function (value, element, params) {
            return Date.parse(value) > Date.parse($(params).val());
            });
            $.validator.unobtrusive.adapters.add("externalidpattern", [], function (options) {
                options.rules["externalidpattern"] = "#" + options.params.otherpropertyname;
                options.messages["externalidpattern"] = options.message;
            });

            $.validator.addMethod("gratherthen", function (value, element, params) {
                return Date.parse(value) > Date.parse($(params).val());
            });
            $.validator.unobtrusive.adapters.add("gratherthen", ["otherproperty"], function (options) {
                options.rules["gratherthen"] = "#" + options.params.otherpropertyname;
                options.messages["gratherthen"] = options.message;
            });

            

Okay now all done. Just need to add above js on page and all done for client and server side validation with custom attribute.

I Hope it will help!
Feel free to add comment. Enjoy coding.

JSON and XML serialization

Hello Friends, Today I will show how we do serialization in JSON and XML.
Today in technologies like JQuery and HTML5 and tons of JavaScript and JSON library, use of JSON and XML are very common.

Technologies like web 2.0 and onwards, MVVM and MVC most of everything done on client site using JSON and XML.

For use JSON and XML in web technology one thing is very important to know for batter use of serialization to object and object to JSON or XML.

In this post I will post some example to how to do serialization for object to JSON or XML and XML or JSON to object.

I am using MVC for demo. You can use this code where ever you want.

Frist we start with JSON Serialization:

1: Create Project and create model for test

             public class TestModel
            {
                public int id { get; set; }
                public string Name { get; set; }
                public List[string] lstskill { get; set; }
                public DateTime Birthday { get; set; }
                public bool Active { get; set; }
                public List[personaldata] Datalst { get; set; }
                public personaldata data { get; set; }
            }
            public class personaldata
            {
                public string data1 { get; set; }
                public string data2 { get; set; }
            }

           

2: Create JSON helper class for serialization

         NOTE: Please add reference of dll 
              [System.Runtime.Serialization.Json]
            
            

         public class JsonHelper
            {
                /// 

                /// JSON Serialization
                /// 
                public static string JsonSerializer[T](T t)
                {
                    DataContractJsonSerializer ser =
                     new DataContractJsonSerializer(typeof(T));
                    MemoryStream ms = new MemoryStream();
                    ser.WriteObject(ms, t);
                    string jsonString = Encoding.UTF8.GetString(ms.ToArray());
                    ms.Close();
                    return jsonString;
                }
                /// 

                /// JSON Deserialization
                /// 
                public static T JsonDeserialize[T](string jsonString)
                {
                    DataContractJsonSerializer ser =
                     new DataContractJsonSerializer(typeof(T));
                    MemoryStream ms =
                     new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
                    T obj = (T)ser.ReadObject(ms);
                    return obj;
                }
            }

        

3: Code for test serialization

For testing add one controller and add action method

        public ActionResult Index()
           {
               var model = new Models.TestModel
               {
                   Active = true,
                   Birthday = DateTime.Now,
                   data = new Models.personaldata
                   {
                       data1 = "data1",
                       data2 = "data2",
                   },
                   Datalst = new List[Models.personaldata]
                   {
                       new Models.personaldata
                       {
                           data1 = "ldata1",
                           data2 = "ldata2",
                       },
                       new Models.personaldata
                       {
                           data1 = "ldata1",
                           data2 = "ldata2",
                       },
                   },
                   id = 3,
                   lstskill = new List[string]
                   {
                       "skill1",
                       "skill2",
                   },
                   Name = "name1"
               };

               var strjson = Helper.JsonHelper.
                       JsonSerializer[Models.TestModel](model);

               var strmodel = Helper.JsonHelper.
                           JsonDeserialize[Models.TestModel](strjson);


               return View();
           }

            

Now, same way can done for XML serialization also.

1: Create XML helper class for serialization

        public class XMLHelper
            {
                public static string XMLSerialize[T](T obj)
                {
                    XmlSerializer serializer = 
                    new XmlSerializer(obj.GetType());
                    using (StringWriter writer = new StringWriter())
                    {
                        serializer.Serialize(writer, obj);
                        return writer.ToString();
                    }
                }

                public static object XMLDeSerialize[T](string data)
                {
                    StringReader rdr = new StringReader(data);
                    XmlSerializer xmlSerializer =
                     new XmlSerializer(typeof(T));
                    var result = (T)xmlSerializer.Deserialize(rdr);
                    return result;
                }
            }

            

2: Code for test serialization

        public ActionResult Index1()
          {
              var model = new Models.TestModel1
              {
                  Active = true,
                  Birthday = DateTime.Now,
                  data = new Models.personaldata1
                  {
                      data1 = "data1",
                      data2 = "data2",
                  },
                  Datalst = new List[Models.personaldata1]
                  {
                      new Models.personaldata1
                      {
                          data1 = "ldata1",
                          data2 = "ldata2",
                      },
                      new Models.personaldata1
                      {
                          data1 = "ldata1",
                          data2 = "ldata2",
                      },
                  },
                  id = 3,
                  lstskill = new List[string]
                  {
                      "skill1",
                      "skill2",
                  },
                  Name = "name1"
              };

              var strXML = Helper.XMLHelper.XMLSerialize[Models.TestModel1](model);
              var strmodel = Helper.XMLHelper.XMLDeSerialize[Models.TestModel1](strXML);
              return View();
          }

            

3: For Map xml attributes to object properties you can use following code

        [XmlRoot("TestModel1")]
            public class TestModel1
            {
                public int id { get; set; }
                [XmlAttribute("Name")]
                public string Name { get; set; }
                [XmlElement(ElementName = "lstskill")]
                public List[string] lstskill { get; set; }
                [XmlAttribute("Birthday")]
                public DateTime Birthday { get; set; }
                public bool Active { get; set; }
                [XmlElement(ElementName = "Datalst")]
                public List[personaldata1] Datalst { get; set; }
                [XmlElement(ElementName = "data")]
                public personaldata1 data { get; set; }
            }
            public class personaldata1
            {
                [XmlAttribute("data1")]
                public string data1 { get; set; }
                [XmlAttribute("data2")]
                public string data2 { get; set; }
            }

             

I Hope it will help!
Feel free to add comment. Enjoy coding.