Sensible pattern for ValidationError class in C#

Question

I am about to implement a class to represent a validation error. The class would definitely contain a string value called Message, which is a default message to display to a user. I also need a way to represent what the validation error is to the programmer. The idea is that there should be an easy way to determine if a particular validation error occurred.

It would be simple to implement a string member called Type, but to determine if a ValidationError is of that type, I would need to remember the string that describes that type.

if (validationError.Type == "PersonWithoutSurname") DoSomething();

Clearly, I need something more strongly typed. An enumeration would be good:

if (validationError.Type == ValidationErrorType.PersonWithoutSurname) DoSomething();

But given the potentially hundreds of types of validation error, I could end up with an ugly enum with hundreds of values.

It also occurred to me to use subclassing:

if (validationError.GetType() == typeof(PersonWithoutSurnameValidationError)) DoSomething();

But then my class library is littered with hundreds of classes which will mostly be used once each.

What do you guys do? I can spend hours agonising over this sort of thing.

Answer go to whoever comes up with the suggestion I use. Enum suggestion is the one to beat.

Answer 1

I use FluentValidation, where you can set up rules for each class, with default or customisable messages for each property.

Because it is a fluent framework, you can combine rules such as:

RuleFor(customer => customer.Address)
   .NotNull().Length(20, 250).Contains("Redmond")
   .WithMessage(@"Address is required, it must contain 
    the word Redmond and must be between 20 and 250 characters in length.");

Typical usage for a validator of the Customer class:

public class CustomerValidator: AbstractValidator<Customer> {
  public CustomerValidator() {
    RuleFor(customer => customer.Surname).NotEmpty();
    RuleFor(customer => customer.Forename).NotEmpty().WithMessage("Please specify a first name");
    RuleFor(customer => customer.Company).NotNull();
    RuleFor(customer => customer.Discount).NotEqual(0).When(customer => customer.HasDiscount);
    RuleFor(customer => customer.Address).Length(20, 250);
    RuleFor(customer => customer.Postcode).Must(BeAValidPostcode).WithMessage("Please specify a valid postcode");
  }

  private bool BeAValidPostcode(string postcode) {
    // custom postcode validating logic goes here
  }
}

Customer customer = new Customer();
CustomerValidator validator = new CustomerValidator();
ValidationResult results = validator.Validate(customer);

bool validationSucceeded = results.IsValid;
IList<ValidationFailure> failures = results.Errors;  
//Bind these error messages to control to give validation feedback to user; 

Answer 2

If the question is storing the types (especially so you can add new ones) how about a config file in XML, or something database driven?

With an app.config you could have:

Which would get called in code:

//Generate the error somehow:
Validation.ErrorType = 
    ConfigurationManager.AppSettings["PersonWithoutSurnameValidationError"].Value;

//Handle the error
[Your string solution here]

This way, you get your error types documented somewhere outside your code so they're easier to remember. If, on the other hand, your main question is the storage so you can get the correct type to handle, stick with the enum.

Answer 3

I seriously don't get why you getting into so much trouble....

If its validating fields that you are doing, then I usually add a regex validator & and a required field validator. For some fields I do add custom validator for my own set of rules. But that's it. For the client side as well as server side. All I do then is a page.validate command which if ever throws an error means the client script has been modified & I usually reload the page as response.

Also if I want to handle a check to single value I use

 System.Text.RegularExpressions.Regex.IsMatch(...

So Is there more to this?? If there is please point out.