Question

I currently got the following method, which is returning me percent-values. For example for an item-price of $350,000 and a percentage of 7%, it returns 24,500.

    public static decimal GetPercentValue(decimal? percentage, decimal baseValue)
    {
        decimal result = 0m;

        if (percentage != null)
        {
            try
            {
                result = Convert.ToDecimal(baseValue * percentage / 100m);
            }
            catch (OverflowException)
            {
                result = 0;
                Logger.Warn("OverflowException caught in GetPercentValue() - should better be handled UI-Sided!");
            }
        }

        return result;
    }

I don’t think this is handled the right way, so is there any way to avoid an exception in this situation?

An OverflowException is being thrown when a user enters an insane number like 999,999,999,999,999,999 and calculates 9999999999% of it. This way I can’t check percentage or baseValue for <= decimal.MaxValue simply because they aren’t… The calculation result itself then exceeds the decimal range.

Answer 1

The error handling should (most likely) be done outside the method. Right now you’re hiding exceptions and returning wrong results (0 is returned when an error occures). The caller of your method cannot tell if the result is correct or if it’s due to an OverflowException.

I’d rewrite the method like that:

public static decimal GetPercentValue(decimal? percentage, decimal baseValue)
{
    if (percentage == null)
        return 0;

    return baseValue*(percentage.Value/100);
}

And optionally add a validation method that the user can call to check the parameters before calling the real method.. validation errors could be displayed in the UI:

public static string ValidatePercentValue(decimal? percentage, decimal baseValue)
{
    try
    {
        GetPercentValue(percentage, baseValue);
        return null;
    }
    catch (Exception ex)
    {
        return ex.Message;
    }
}

Besides that note that…

baseValue*(percentage.Value/100)

… is better than…

baseValue*percentage.Value/100

Try to calculate 100% of decimal.MaxValue. The first one works while the second one throws an OverflowException.