wxyz.Validator 1.0.4

wxyz-Validator

Yet another validator for C# data object

Flow:

// validate with new context
new Validator<V,T>(T value)
   --> new ValidatorContext ctx
       --> static cache[new V()]
           --> void static Validator.Validate(value, ctx)
               --> cache[V].Test(value, ctx)
                   --> onSuccess, onError


// validate without using the onSuccess, onError
ValidatorContext ctx;  // handles the result, Disposable
static Validator<V,T>.Validate(T value, ValidatorContext ctx)
   --> if !cache[V] then cache[new V()]
       --> cache[V].Test(value, ctx);


ValidatorBase<T>.chain<V, X>(X value, ValidatorContext ctx)
   --> Validator<V, X>.Validate(value, ctx);

Sample

class Person {
  public string name { get; set; }
  public int age { get; set; }
}

Validator

sealed class PersonValidator : ValidatorBase<Person> {

    public override void Test(Person value, ValidatorContext context) {
      // MUST be called before any assertion
      use(value, context);

      required(value.name, "name is required");
      required(value.age, "age is required");
      min(value.age, 18);
    }

}

Using lambda in validation rule

public override void Test(Person value, ValidatorContext context) {
  // MUST be called before any assertion
  use(value, context);

  ...
  assert(x => x.age > 0, "non-zero positive number only for parameter age");
  assert(x => x.age >= 12 && x.age <= 18, "age must be in range 12 to 18");
}

Running validator

public static void main(String[] args) {
  var info = new Person { name = "Juan Puruntong", age = "16" };

  using(var result = new Validator<PersonValidator, Person>(info)) {
    result.onSuccess(x => {
      Console.WriteLine(x.name);
    })
    .onError((errors, x) => {
      foreach(String message in errors) {
        Console.WriteLine(message);
      }
      Console.WriteLine("Error(s):{0}", errors.Count);
    });
  }
}

Chaining validators

class Address {
  public string country { get; set; }
  public string province { get; set; }
}

sealed class AddressValidator : ValidatorBase<Address> {

  public override void Test(Address value, ValidatorContext context) {
    // MUST be called before any assertion
    use(value, context);

    required(value.country);
    required(value.province);
  }

}

Calling chain

class Person {
  ...
  public Address address { get; set; }
}

sealed class PersonValidator : ValidatorBase<Person> {

    public override void Test(Person value, ValidatorContext context) {
      // MUST be called before any assertion
      use(value, context);

      ...
      required(value.address);
      chain<AddressValidator, Address>(value.address);
    }

}

Validator<V,T> runs in a single ValidatorContext to prevent validation loop when calling chain<V,T>(T value) in a ValidatorBase<T> child class.

Run validator using static Validator<V,T>.Validate

var ctx = new ValidatorContext();
Validator<PersonRules, Person>.Validate(info);
foreach(string message in ctx.GetErrors()) {
  Console.WriteLine(message);
}