Deriving decimal types - fixed precision

Question

Is there a way in .NET to create a type derived from decimal that would be used as a currency, so it rounds the arithmetic operations to the desired number of decimal points.

If not, what are the best practice for it in .NET?

EDIT (motivation):

Let's say I have a price:

125.00 Rep$

and I sell 0.25 pieces of it, that amounts to 31.25

Now, I have a discount of 15%, and to calculate discount and present it in absolute value I'll have:

31.25 * .85 = 26.5625

If I use other way:

31.25 * .15 = 4.6875

If I let some 3rd party control to truncate it and display it, for example, I could have:

26.56 +
 4.68 =
-----
31.24

And every accountant will eat your hearth if you give her something like that.

Add tax here, and problem multiplies further.

So, NO storing as much decimals and rounding it as late as possible. Create a class that will do it financially correct and store it as soon as possible rounded/truncated.

It's very strange how I get many answers 'use rounding as late as possible' when I see only trouble if I do so. Accountancy MUST NOT have hidden digits! — Daniel Mošmondor, Dec 24 '10 at 11:22
But rounding intermediate steps is far worse--you are not just "hiding" digits, you are losing them all together, as if they were never there! — Polyfun, Dec 24 '10 at 12:57
@SS: you have to lose them, because there is no way you can pay out $0.003. HOW to lose them, that is something that you have to decide and stick with later on. — Daniel Mošmondor, Dec 24 '10 at 14:24

Jon Skeet · Accepted Answer · 2010-12-24T10:37:52.630

You certainly can't create a type derived from decimal, as it's a struct - and you can't create subtypes of structs.

You could create your own Currency struct which contained a decimal, though. You'd want to overload all the arithmetic operators to basically perform the arithmetic on the contained decimal values and then round appropriately.

For example:

public struct Currency
{
    private readonly decimal value;

    public Currency(decimal value)
    {
        this.value = decimal.Round(value, 2);
    }

    public override string ToString()
    {
        return value.ToString();
    }

    public static Currency operator+(Currency left, Currency right)
    {
        return new Currency(left.value + right.value);
    }

    public static Currency operator-(Currency left, Currency right)
    {
        return new Currency(left.value - right.value);
    }

    public static Currency operator/(Currency left, int right)
    {
        return new Currency(left.value / right);
    }
}

class Test
{
    static void Main()
    {
        Currency currency = new Currency(15);
        Console.WriteLine(currency / 10); // Prints 1.5
        Console.WriteLine(currency / 100); // Prints 0.15
        Console.WriteLine(currency / 1000); // Prints 0.2
    }
}

(Obviously there's a lot more needed here - in particular you'll want to override GetHashCode and Equals, implement IEquatable<T> etc.)

Is this definitely what you want though? I thought it was more common to keep as much precision as you could during intermediate operations, and only round at the last moment, e.g. for storage in a database or display to a user.

Thanks for the code, @Jon, I added some motivation to my question, as an answer to your question... — Daniel Mošmondor, Dec 24 '10 at 11:21

score 1 · Answer 2 · answered Dec 24 '10 at 10:34

1

What you propose cannot be done directly (deriving from a value type like decimal). It is also not a good idea, since rounding after every arithmetic operation will introduce larger and larger errors into the final result.

If I understand correctly, what you want to achieve is best done by using decimal normally, and using System.Math.Round once, at the end for rounding.

answered Dec 24 '10 at 10:34

Jon

428,835
81
738
806

Exactly. By rounding intermediate steps you lose a bit of precision at each step, which will be compounded by the number of steps, resulting in a very imprecise final answer. – Polyfun Dec 24 '10 at 12:55

score 0 · Answer 3 · answered Dec 24 '10 at 10:33

0

System.Decimal should already have what you need, if you use the: The Currency ("C") Format Specifier to output a decimal value.

answered Dec 24 '10 at 10:33

Simon Mourier

132,049
21
248
298

Deriving decimal types - fixed precision

3 Answers3