Elegant way to validate values

I have a class with many fields which represents different physical values.

class Tunnel
{
    private double _length;
    private double _crossSectionArea;
    private double _airDensity;
    //...

Each field is exposed using read/write property. I need to check on sette开发者_开发百科r that the value is correct and generate exception otherwise. All validations are similar:

    public double Length
    {
        get { return _length; }
        set
        {
            if (value <= 0) throw new ArgumentOutOfRangeException("value",
                    "Length must be positive value.");
            _length = value;
        }
    }

    public double CrossSectionArea
    {
        get { return _crossSectionArea; }
        set
        {
            if (value <= 0) throw new ArgumentOutOfRangeException("value",
                    "Cross-section area must be positive value.");
            _crossSectionArea = value;
        }
    }

    public double AirDensity
    {
        get { return _airDensity; }
        set
        {
            if (value < 0) throw new ArgumentOutOfRangeException("value",
                    "Air density can't be negative value.");
            _airDensity = value;
        }
    }
    //...

Is there any elegant and flexible way to accomplish such validation?

Assuming you want this sort of behaviour, you might consider some helper methods, e.g.

public static double ValidatePositive(double input, string name)
{
    if (input <= 0)
    {
        throw new ArgumentOutOfRangeException(name + " must be positive");
    }
    return input;
}

public static double ValidateNonNegative(double input, string name)
{
    if (input < 0)
    {
        throw new ArgumentOutOfRangeException(name + " must not be negative");
    }
    return input;
}

Then you can write:

public double AirDensity
{
    get { return _airDensity; }
    set
    {            
        _airDensity = ValidationHelpers.ValidateNonNegative(value,
                                                            "Air density");
    }
}

If you need this for various types, you could even make it generic:

public static T ValidateNonNegative(T input, string name)
    where T : IComparable<T>
{
    if (input.CompareTo(default(T)) < 0)
    {
        throw new ArgumentOutOfRangeException(name + " must not be negative");
    }
    return input;
}

Note that none of this is terribly i18n-friendly...

All depends what technology you are using - if you're under MVC you can use Attributes, like this;

http://msdn.microsoft.com/en-us/library/ee256141(v=vs.98).aspx

Here's my version, it's a bit cleaner than Jon's version in some respects:

interface IValidator <T>
{
  bool Validate (T value);
}

class IntValidator : IValidator <int>
{
  public bool Validate (int value)
  {
    return value > 10 && value < 15;
  }
}
class Int2Validator : IValidator<int>
{
  public bool Validate (int value)
  {
    return value > 100 && value < 150;
  }
}

struct Property<T, P> where P : IValidator<T>, new ()
{
  public T Value
  {
    set
    {
      if (m_validator.Validate (value))
      {
        m_value = value;
      }
      else
      {
        Console.WriteLine ("Error validating: '" + value + "' is out of range.");
      }
    }

    get { return m_value; }
  }

  T m_value;
  static IValidator<T> m_validator=new P();
}

class Program
{
  static void Main (string [] args)
  {
    Program
      p = new Program ();

    p.m_p1.Value = 9;
    p.m_p1.Value = 12;
    p.m_p1.Value = 25;
    p.m_p2.Value = 90;
    p.m_p2.Value = 120;
    p.m_p2.Value = 250;
  }

  Property<int, IntValidator>
    m_p1;

  Property<int, Int2Validator>
    m_p2;
}

Try to use such a method:

 public void FailOrProceed(Func<bool> validationFunction, Action proceedFunction, string errorMessage)
    {
        // !!! check for nulls, etc
        if (!validationFunction())
        {
            throw new ArgumentOutOfRangeException(errorMessage);
        }

        proceedFunction();
    }

Yes, by creating your own validation attributes.

Read this article: Business Object Validation Using Attributes in C#

I will have the decency of NOT copying it here :)

Using the Validator function I mentioned in my comment above, I'd do something like this (untested code):

void textBox_Changed(object sender, EventArgs e) {
  submitButton.Enabled = validator();
}

bool validator() {
  const string NON_POSITIVE = "Value must be greater than Zero";
  bool result = false;
  string controlName = "Length";
  try {
    _length = Convert.ToDouble(txtLength.Text);
    if (_length <= 0) throw new Exception(NON_POSITIVE);
    controlName = "Cross Section Area";
    _crossSectionArea = Convert.ToDouble(txtCrossSectionArea.Text);
    if (_crossSectionArea <= 0) throw new Exception(NON_POSITIVE);
    controlName = "Air Density";
    _airDensity = Convert.ToDouble(txtAirDensity.Text);
    if (_airDensity <= 0) throw new Exception(NON_POSITIVE);
    result = true; // only do this step last
  } catch (Exception err) {
    MessageBox.Show(controlName + " Error: " + err.Message, "Input Error");
  }
  return result;
}

John Skeet probably has a better way, but this works. :)

You can achieve this using classes from System.ComponentModel.DataAnnotations

class Tunnel
{
    [Range(0, double.MaxValue, ErrorMessage = "Length must be positive value.")]
    public double Length { get; set; }
}

Validation:

var tunnel = new Tunnel { Length = 0 };
var context = new ValidationContext(tunnel, null, null);
Validator.ValidateObject(tunnel, context, true);

Also you can implement your own validation attributes overriding ValidationAttribute class