Click here to Skip to main content
Click here to Skip to main content
Go to top

Creating Validation Engine for Domain Objects

, 15 Aug 2008
Rate this:
Please Sign up or sign in to vote.
In this article we will build a simple domain object validation framework using custom attributes and reflection.

Introduction

The brain of the application is represented by the domain. The domain consists of the business rules which make the application function properly. The rules must be validated in order to guarantee a successful operation. In this article we will build a simple domain object validation framework using custom attributes and reflection.

What does Domain Object Validation Means?

First we need to understand what domain objects validation means. Let’s consider a simple class Customer which is domain object. The Customer class consists of properties like FirstName, LastName etc. We need to make sure that the user does not leave FirstName and LastName empty. Of course, we can always use ASP.NET validation controls to make sure that the user inserts the fields but that validation is performed on the user interface level. We need to provide another layer of validation which validate the object based on the more complex business rules.

The Class Diagram

Take a look at the complete class diagram of the validation framework.

classdiagramvalidationframework_small.PNG

Now, let’s take a dive into the implementation.

Creating the Abstract ValidationAttribute Custom Attribute

The first task is to create custom attributes. To create an attribute your class must inherit from System.Attribute. Check out the implementation of the ValidationAttribute class below which serves as the abstract base class for all the validation attributes.

   public abstract class ValidationAttribute : System.Attribute
    {
        public string Message { get; set; }

        public abstract bool IsValid(object item);        
    }

The ValidationAttribute class contains the properties and the methods that will be used and implemented by all the other validation classes.

Implementing the NotNullOrEmptyAttribute

Let’s implement the first validation attribute “NotNullOrEmptyAttribute.” This will make sure that the value of an object is not null or empty.

[AttributeUsage(AttributeTargets.Property)]
    public class NotNullOrEmptyAttribute : ValidationAttribute
    {       

        public NotNullOrEmptyAttribute(string message)
        {
            Message = message;
        }
        
        public override bool IsValid(object item)
        {
            if (String.IsNullOrEmpty((string)item))
                return false;

            return true;             
        }
    }

As, you can see the implementation is quite simple! The IsValid method checks that if the value passed is valid or not. The good thing about using attribute based validation is that you can add more rules just by adding more custom attributes. The attribute can be decorated on the Customer class using the following syntax.

public class Customer : BusinessBase
    {
        [NotNullOrEmpty("First name cannot be null or empty")]
        public string FirstName { get; set; }

        [NotNullOrEmpty("First name cannot be null or empty")]
        public string LastName { get; set; }
    }

Implementing the ValidationEngine

The ValidationEngine class is responsible for validating the business objects. Here is the complete implementation of the ValidationEngine.Validate<T> method.

public static bool Validate<T>(T item) where T : BusinessBase
        {
            var properties = item.GetType().GetProperties(
                BindingFlags.Public | BindingFlags.Instance);

            foreach (var property in properties)
            {
                var customAtt = property.GetCustomAttributes(typeof(ValidationAttribute),
                    true);

                foreach (var att in customAtt)
                {
                    var valAtt = att as ValidationAttribute;
                    if (valAtt == null) continue;

                    if (valAtt.IsValid(property.GetValue(item, null))) continue;

                    var brokenRule = new BrokenRule
                                         {
                                             Message = String.Format("{0}:{1}",
                                             property.Name, valAtt.Message),
                                             PropertyName = property.Name
                                         };
                    item.BrokenRules.Add(brokenRule);
                }

            }

            return (item.BrokenRules.Count == 0);
        }

The Validate<T> method simply extracts all the properties from the object and check to see if it is decorated with the custom attribute of ValidationAttribute type. If it is then it invokes the IsValid method on the custom attribute class. If the object is not valid then the broken rules are added to the BrokenRules collection.

If you are more interested in validating your objects using the Customer.IsValid syntax then check out the following article which uses extension methods to add the extended functionality.

Desinging Application Using Test Driven Development Part 2

Using the ValidationEngine

ValidationEngine is pretty simple to use. Simply, pass in your object to the ValidationEngine.Validate<T> method and check to see if your object is valid or not based on the returned value. You also need to make sure that your object’s properties are decorated with correct validation attributes.

static void Main(string[] args)
        {
            var customer = new Customer();

            ValidationEngine.Validate(customer);

            foreach(var brokenRule in customer.BrokenRules)
            {
                Console.WriteLine(brokenRule.Message);
            }
        }

Also, note that BrokenRules is a List<BrokenRule> collection which implements the IEnumerable interface. This means that you can easily bind your broken rules to a databound control like Repeater, ListView, DataList, DataGrid or GridView.

validationEngine_002.GIF

Conclusion

In this article we learned how to validate the business objects using custom attributes and reflection. You can extend the ValidationEngine class by providing more custom attributes each targeting a certain area of validation.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

azamsharp
Web Developer
United States United States
I am the founder of knowledge base website, HighOnCoding, GridViewGuy, RefactorCode.com and ScreencastADay.com.
 
HighOnCoding is a website which will get you high legally with useful information. There are tons of articles, videos and podcasts hosted on HighOnCoding.
 
HighOnCoding.com www.HighOnCoding.com
 

My Blog:

Blog

 

Buy my iPhone app ABC Pop

Comments and Discussions

 
GeneralUse Case PinmemberChris Mulvey27-Apr-10 12:25 
GeneralRe: Use Case Pinmemberazamsharp27-Apr-10 14:19 
GeneralGreat example Pinmemberhammerstein0520-Nov-09 7:18 
Generalsome thoughts PinmemberDaProgramma18-Aug-08 21:18 
GeneralValidation Engine and Attributes Pinmemberliammclennan18-Aug-08 15:37 
GeneralRe: Validation Engine and Attributes Pinmemberazamsharp18-Aug-08 16:09 
GeneralRe: Validation Engine and Attributes PinmemberManishaPol18-Mar-10 2:00 
GeneralCSLA PinmemberHoyaSaxa9316-Aug-08 3:40 
GeneralRe: CSLA Pinmemberazamsharp16-Aug-08 4:19 
QuestionWhy don't you use the Validation Application Block? PinmemberKing_kLAx15-Aug-08 22:41 
I have used this on multiple projects and have no complaints:
 
http://msdn.microsoft.com/en-us/library/cc309320.aspx[^]
 
using Microsoft.Practices.EnterpriseLibrary.Validation;
using Microsoft.Practices.EnterpriseLibrary.Validation.Validators;
public class Customer
{
    [StringLengthValidator(0, 20)]
    public string CustomerName;
 
    public Customer(string customerName)
    {
        this.CustomerName = customerName;
    }
}
 
public class MyExample
{
    public static void Main() 
    {
        Customer myCustomer = new Customer("A name that is too long");
        ValidationResults r = Validation.Validate<Customer>(myCustomer);
        if (!r.IsValid)
        {
            throw new InvalidOperationException("Validation error found.");
        }
    }
} 

 
Ian

AnswerRe: Why don't you use the Validation Application Block? Pinmemberazamsharp16-Aug-08 4:17 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Mobile
Web04 | 2.8.140916.1 | Last Updated 15 Aug 2008
Article Copyright 2008 by azamsharp
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid