异常处理 - 这是一种好的做法吗？

Question

I am wondering if what i am going to do is good or bad thing. I have that class:

public class Element : IElement
{
    public float? Max { get; private set; }

    public float? Min { get; private set; }

    public float? Average { get; private set; }

    public bool HasValue { get; private set; }


    public void SetRange(float? min, float? max)
    {
        if (min >= max)
        {
           throw new WrongElementValueException("Min must be greater than max!");
        }
        else if (min < 0f || max < 0f)
        {
           throw new WrongElementValueException("Min/max must be greater than 0!");
        }
        else if (min > 100f || max > 100f)
        {
           throw new WrongElementValueException("Min/max must be lesser than 0!");
        }
        else
        {
            Min = min;
            Max = max;
            Average = (min + max)/2f;
            HasValue = true;
        }
    }
}

The user will set the values using SetRange() method. But he has some constraints like Min must be bigger than Max, and neither of them should be bigger than 100 or lesser than 0.

Should I use those exceptions in this place? Or is there any better method to handle wrong user input? I hope my question isn't to general.

Answer 1

This is an appropriate practice, yes.

Though I imagine consuming code would be expecting an ArgumentException rather than this exception type, but that may be a relatively minor point.

When the input is invalid, and the object has no way of meaningfully continuing otherwise, then throwing an exception is an appropriate and expected response. It's up to consuming code to use the object properly, handle errors, report back to the user, etc.

The alternative is for this object to "try to figure out what to do" which often leads to some pretty bad coding practices. For example...

• Suppose you instead want to return an error message instead of throwing an exception. What if consuming code doesn't check for that error message? The object would be left in an unknown and invalid state and could quietly introduce bugs. Whereas if consuming code didn't check for the exception then the program would clearly and obviously fail and would need to be appropriately corrected. Clear and obvious failures are a lot easier to support than subtle and unnoticed ones.
• Suppose you want to "show a message to the user" instead. That would requiring tightly coupling this object to a presentation layer, which defeats object oriented principles and makes the code very rigid and difficult to maintain.

This object does one thing, and only that one thing. If it's invoked in such a way that it can't do that one thing, an exception is an expected and appropriate failure condition.

Answer 2

An excption is usefull whenever a valid program-flow is not possible (eg connection to database lost). Proofing user-input and throwing exception if values are not valid is absolutely ok thus, whereas you may also use the allready suggested ArgumentException .

Answer 3

else if (min < 0f || max < 0f)
  throw new WrongElementValueException("Min/max must be greater than 0!");
else if (min > 100f || max > 100f)
  throw new WrongElementValueException("Min/max must be lesser than 0!");

I'd note that there is already ArgumentOutOfRangeException that's defined for precisely this sort of case.

if (min >= max)
  throw new WrongElementValueException("Min must be greater than max!");

This should definitely be an ArgumentException , but if WrongElementValueException inherits from ArgumentException , then that's fine.

Your general approach is sound. I'd consider going further:

HasValue = true;

Why allow for the class to ever not have a value. Consider if you add:

public Element(float min, float max)
{
  SetRange(min, max);
}

Now you can never have an instance without its values set, and can get rid of HasValue entirely.

Note though that I changed this from float? to float . You might well be advised to do that throughout the class. Otherwise if you have a need for cases where Min and Max are null, (and therefore don't want to get rid of HasValue ) you need to catch that case in SetRange :

public void SetRange(float? min, float? max)
{
    if (min < 0f || max < 0f || min > 100f || max > 100f)
      throw new ArgumentOutOfRangeException();
    if (min >= max)
      throw new WrongElementValueException("Min must be greater than max!");
    Min = min;
    Max = max;
    if(min.HasValue && max.HasValue)
    {
        Average = (min + max)/2f;
        HasValue = true;
    }
    else
    {
      Average = null;
      HasValue = false;
    }
}

(I'd also generally favour double and double? over float and float? unless you've a strong reason otherwise).

Incidentally, we generally use "exception handling" to talk about how code that's using this code deals with the fact that your code threw an exception, with just what the best thing to do is depending on the context of that code rather than this code.

Answer 4

It's good practice to handle exception in program if you are throwing and catching it correctly. But here it's trivial matter ,no need to throw and object where as you can restrict it by simple console print.

Both will work same in this scenario.

Throwing an exception would much useful when there are many inner function calls and you don't know which one will cause exception at that time.

and By the way don't you think these is wrong one.

if (min >= max) throw new WrongElementValueException("Min must be greater than max!"); // your are printing min should be greater than max and you are checking the same.