Validating data in .net

Question

I’m looking for any recommended validation framework or templates for an N-level client application, I want to write a verification method once and bind it to the WPF GUI, as well as, possibly, for the server and client-side business logic.

Answer 1

Very simple, your business entities should include a section for storing Business Validation (this is business logic). This will then work regardless of whether you are developing a web application, a client application, a mobile application, etc. Very flexible.

Suppose you have a business object (object), such as a client:

public class Customer { public Customer(int customerId, string company, string city, string country) { CustomerId = customerId; Company = company; City = city; Country = country; } } 

Then you understand that you want your business logic to indicate that you are checking the customer identifier (in addition, it is> 0), you need the name of the company (it is not valid without one client), etc. These checks are your level of business logic. Thus, you can change your client class to inherit using the BusinessObject layer so that your class becomes the following:

  public class Customer : BusinessObject { /// <summary> /// Default constructor for customer class. /// Initializes automatic properties. /// </summary> public Customer() { // Default property values Orders = new List<Order>(); // Business rules AddRule(new ValidateId("CustomerId")); AddRule(new ValidateRequired("Company")); AddRule(new ValidateLength("Company", 1, 40)); } /// <summary> /// Overloaded constructor for the Customer class. /// </summary> /// <param name="customerId">Unique Identifier for the Customer.</param> /// <param name="company">Name of the Customer.</param> /// <param name="city">City where Customer is located.</param> /// <param name="country">Country where Customer is located.</param> public Customer(int customerId, string company, string city, string country) : this() { CustomerId = customerId; Company = company; City = city; Country = country; } //much more code like methods... } 

You do not need objects of type BusinessObject, but which business object serves as an abstract class that stores validation errors and business rules. A business rule is ultimately the rule that you specified when you called AddRule:

 public abstract class BusinessObject { /// <summary> /// Default value for version number (used in LINQ optimistic concurrency) /// </summary> protected static readonly string _versionDefault = "NotSet"; // List of business rules private IList<BusinessRule> _businessRules = new List<BusinessRule>(); // List of validation errors (following validation failure) private IList<string> _validationErrors = new List<string>(); /// <summary> /// Gets list of validations errors. /// </summary> public IList<string> ValidationErrors { get { return _validationErrors; } } /// <summary> /// Adds a business rule to the business object. /// </summary> /// <param name="rule"></param> protected void AddRule(BusinessRule rule) { _businessRules.Add(rule); } /// <summary> /// Determines whether business rules are valid or not. /// Creates a list of validation errors when appropriate. /// </summary> /// <returns></returns> public bool Validate() { bool isValid = true; _validationErrors.Clear(); foreach (BusinessRule rule in _businessRules) { if (!rule.Validate(this)) { isValid = false; _validationErrors.Add(rule.ErrorMessage); } } return isValid; } } 

Each business rule, such as validateid, validaterequired, and validatelength, must be implemented:

 public class ValidateId : BusinessRule { public ValidateId(string propertyName) : base(propertyName) { ErrorMessage = propertyName + " is an invalid identifier"; } public ValidateId(string propertyName, string errorMessage) : base(propertyName) { ErrorMessage = errorMessage; } public override bool Validate(BusinessObject businessObject) { try { int id = int.Parse(GetPropertyValue(businessObject).ToString()); return id >= 0; } catch { return false; } } public class ValidateLength : BusinessRule { private int _min; private int _max; public ValidateLength(string propertyName, int min, int max) : base(propertyName) { _min = min; _max = max; ErrorMessage = propertyName + " must be between " + _min + " and " + _max + " characters long."; } public ValidateLength(string propertyName, string errorMessage, int min, int max) : this(propertyName, min, max) { ErrorMessage = errorMessage; } public override bool Validate(BusinessObject businessObject) { int length = GetPropertyValue(businessObject).ToString().Length; return length >= _min && length <= _max; } } 

These are just two samples validatelength and validateid, you can come up with validaterequired (check if this value exists). They both implement the business rule class:

 public abstract class BusinessRule { public string PropertyName { get; set; } public string ErrorMessage { get; set; } /// <summary> /// Constructor /// </summary> /// <param name="propertyName">The property name to which rule applies.</param> public BusinessRule(string propertyName) { PropertyName = propertyName; ErrorMessage = propertyName + " is not valid"; } /// <summary> /// Overloaded constructor /// </summary> /// <param name="propertyName">The property name to which rule applies.</param> /// <param name="errorMessage">The error message.</param> public BusinessRule(string propertyName, string errorMessage) : this(propertyName) { ErrorMessage = errorMessage; } /// <summary> /// Validation method. To be implemented in derived classes. /// </summary> /// <param name="businessObject"></param> /// <returns></returns> public abstract bool Validate(BusinessObject businessObject); /// <summary> /// Gets value for given business object property using reflection. /// </summary> /// <param name="businessObject"></param> /// <param name="propertyName"></param> /// <returns></returns> protected object GetPropertyValue(BusinessObject businessObject) { return businessObject.GetType().GetProperty(PropertyName).GetValue(businessObject, null); } } 

Thus, your business class simply keeps a list of the necessary business rules and validation errors that it catches. The business rule class simply saves the property name and error message if the rule is not applied correctly. It also contains the abstract validate () method, which is defined for each validation class. It is different for each validation class, because validating the identifier is different and then validating the correct field.

The gang of four websites has a lot of good help in this regard. Most of this code is taken from their models.

Answer 2

A simple codeplex search returns many validation frameworks. Many make very similar methods, as JonH mentions. Something like net Validation framework seems to fit your criteria.