Creating Validation Engine for Domain Objects

• Download source files - 139.51 KB

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.

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.

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.

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.