Reversible tax calculator class

Question

I have a class that contains 2 properties of the same type. decimal NetAmount and decimal GrossAmount

I would like to initialize it using either GrossAmount or NetAmount and based on the one specified calculate the second one.

Which way is the most elegant and why? (parameter validation is omitted for brevity)

1

public class TaxedPrice
{
    private TaxedPrice()
    { }

    public decimal NetAmount { get; private set; }
    public decimal GrossAmount { get; private set; }

    public static TaxedPrice FromNet(decimal netAmount, decimal taxRate)
    {
        return new TaxedPrice
        {
            NetAmount = decimal.Round(netAmount, 2, MidpointRounding.AwayFromZero),
            GrossAmount = decimal.Round(netAmount.ApplyTax(taxRate), 2, MidpointRounding.AwayFromZero)
        };
    }

    public static TaxedPrice FromGross(decimal grossAmount, decimal taxRate)
    {
        return new TaxedPrice
        {
            GrossAmount = decimal.Round(grossAmount, 2, MidpointRounding.AwayFromZero),
            NetAmount = decimal.Round(grossAmount.RemoveTax(taxRate), 2, MidpointRounding.AwayFromZero)
        };
    }
}

2

public class TaxedPrice
{
    public TaxedPrice(decimal netAmount, decimal grossAmount, decimal taxRate)
    {
        if (grossAmount != default)
        {
            GrossAmount = decimal.Round(grossAmount, 2, MidpointRounding.AwayFromZero);
            NetAmount = decimal.Round(grossAmount.RemoveTax(taxRate), 2, MidpointRounding.AwayFromZero);
        }
        else if (netAmount != default)
        {
            NetAmount = decimal.Round(netAmount, 2, MidpointRounding.AwayFromZero);
            GrossAmount = decimal.Round(netAmount.ApplyTax(taxRate), 2, MidpointRounding.AwayFromZero);
        }
        else
        {
            throw new InvalidOperationException($"Either {nameof(netAmount)} or {grossAmount} must be set.");
        }
    }

    public decimal NetAmount { get; }
    public decimal GrossAmount { get; }
}

3

public class TaxedPrice
{
    public enum Type
    {
        Gross,
        Net
    }

    public TaxedPrice(decimal amount, Type type, decimal taxRate)
    {
        if (type == Type.Gross)
        {
            GrossAmount = decimal.Round(amount, 2, MidpointRounding.AwayFromZero);
            NetAmount = decimal.Round(amount.RemoveTax(taxRate), 2, MidpointRounding.AwayFromZero);
        }
        else if (type == Type.Net)
        {
            NetAmount = decimal.Round(amount, 2, MidpointRounding.AwayFromZero);
            GrossAmount = decimal.Round(amount.ApplyTax(taxRate), 2, MidpointRounding.AwayFromZero);
        }
    }

    public decimal NetAmount { get; }
    public decimal GrossAmount { get; }
}

4

public class TaxedPrice
{
    public TaxedPrice(decimal amount, bool fromGross, decimal taxRate)
    {
        if (fromGross)
        {
            GrossAmount = decimal.Round(amount, 2, MidpointRounding.AwayFromZero);
            NetAmount = decimal.Round(amount.RemoveTax(taxRate), 2, MidpointRounding.AwayFromZero);
        }
        else
        {
            NetAmount = decimal.Round(amount, 2, MidpointRounding.AwayFromZero);
            GrossAmount = decimal.Round(amount.ApplyTax(taxRate), 2, MidpointRounding.AwayFromZero);
        }
    }

    public decimal NetAmount { get; }
    public decimal GrossAmount { get; }
}

How it looks like from caller's side:

// 1
var taxedPrice = TaxedPrice.FromNet(2.123m, 0.23m);
// 2
var taxedPrice = new TaxedPrice(2.123m, default, 0.23m); // uses the first one to calculate the second one
var taxedPrice2 = new TaxedPrice(2.123m, 1.11m, 0.23m); // uses the first one to calculate the second one
var taxedPrice3 = new TaxedPrice(default, 1.11m, 0.23m); // uses the second one to calculate the first one
// 3
var taxedPrice = new TaxedPrice(2.123m, TaxedPrice.Type.Net, 0.23m);
// 4 
var taxedPrice = new TaxedPrice(2.123m, false, 0.23m);

Extensions for tax:

public static class TaxExtensions
{
    public static decimal ApplyTax(this decimal netPrice, decimal taxRate)
    {
        return netPrice * (taxRate + 1);
    }

    public static decimal RemoveTax(this decimal grossPrice, decimal taxRate)
    {
        return grossPrice / (taxRate + 1);
    }
}

Mapping perspective

In my upper layer I pass those prices in POCOs/DTOs like:

public class PriceDTO
{
    public decimal NetAmount { get; set; }
    public decimal GrossAmount { get; set; }
}

And I have to check there as well which one was passed to decide from which to calculate. So in case of 1 mapping would look like:

if (priceDto.GrossAmount != default)
    return TaxedPrice.FromGross(priceDto.GrossAmount, taxRate);
else if (priceDto.NetAmount != default)
    return TaxedPrice.FromNet(priceDto.NetAmount, taxRate);
else
    // error

In case of 2 (no need to check in the mapping code)

return new TaxedPrice(priceDto.NetAmount, priceDto.GrossAmount, taxRate)

3 - there's a check as well

4 - same like 1 and 3

And I agree this could be a struct instead.

Answer 1

I'd personally go for option one as it's by far the simplest, as the names FromNet and FromGross give a clear indication of what the code is doing. That clarity is lost in the other examples.

However, there is room to improve things. Both methods perform the same basic calculation, resulting in four near-dentical expressions. So DRY can be applied here:

public class TaxedPrice
{
    private TaxedPrice()
    { }

    public decimal NetAmount { get; private set; }
    public decimal GrossAmount { get; private set; }

    public static TaxedPrice FromNet(decimal netAmount, decimal taxRate)
    {
        return new TaxedPrice
        {
            NetAmount = ApplyRounding(netAmount),
            GrossAmount = ApplyRounding(netAmount.ApplyTax(taxRate))
        };
    }

    public static TaxedPrice FromGross(decimal grossAmount, decimal taxRate)
    {
        return new TaxedPrice
        {
            GrossAmount = ApplyRounding(grossAmount),
            NetAmount = ApplyRounding(grossAmount.RemoveTax(taxRate))
        };
    }

    private decimal ApplyRounding(decimal rawValue)
        => decimal.Round(rawValue, 2, MidpointRounding.AwayFromZero)

}

Answer 2

In my opinion, you should go for number 1 (with one small change).

Reasons for choosing this one:

1. Easy to modify - you can add new FromX method
2. Clear - it states exactly what do you calculate
3. Doesn't require explanation beforehand to do some checking by consumer (as in number 2)

Drawback:

(big one) It might disrupt testing, mocking a static method is a nightmare (unless you can afford moles).

Taking this all into account, I'd do a little bit of overengeneering and create a factory(-ish) class to build you a TaxedPrice object. For example:

public class TaxedPriceFactory: ITaxedPriceFactory {
    public TaxedPrice CreateFromNet(decimal netAmount, decimal taxRate) { 
    //body
    }

    public TaxedPrice CreateFromGross(decimal grossAmount, decimal taxRate){ 
    // body
    }
}

This should have all three of advantages I mentioned earlier and it is easy to use in tests now.

Addendum: Consider making your TaxedPrice a immutable struct instead of a class with two read-only properties.

EDIT: class and method names changed as suggested by @t3chb0t

Answer 3

Another possible option. Make NetAmount and GrossAmount first-class types in your system and provide implicit conversions. The only problem I'm having is how to specify a tax rate each call like the original (mine is somewhat global as you'll see by the usage example at the end). If someone has a good workaround on that front, I'd love to see it. You can also add equality/comparison methods and operators and have it implement as many interfaces (like decimal does) as you like.

NetAmount.cs

public struct NetAmount
{
    private static decimal _globalTaxRate;

    public NetAmount(decimal amount, decimal globalTaxRate)
    {
        this.Amount = decimal.Round(amount, 2, MidpointRounding.AwayFromZero);
        _globalTaxRate = globalTaxRate;
    }

    public decimal Amount { get; }

    public static decimal GlobalTaxRate => _globalTaxRate;

    public static implicit operator decimal(NetAmount netAmount)
    {
        return netAmount.Amount;
    }

    public static implicit operator NetAmount(decimal amount)
    {
        return new NetAmount(amount, _globalTaxRate);
    }

    public static implicit operator GrossAmount(NetAmount netAmount)
    {
        return decimal.Round(netAmount.ApplyTax(_globalTaxRate), 2, MidpointRounding.AwayFromZero);
    }

    public override string ToString()
    {
        return this.Amount.ToString();
    }
}

GrossAmount.cs

public struct GrossAmount
{
    private static decimal _globalTaxRate;

    public GrossAmount(decimal amount, decimal globalTaxRate)
    {
        this.Amount = decimal.Round(amount, 2, MidpointRounding.AwayFromZero);
        _globalTaxRate = globalTaxRate;
    }

    public decimal Amount { get; }

    public static decimal GlobalTaxRate => _globalTaxRate;

    public static implicit operator decimal(GrossAmount grossAmount)
    {
        return grossAmount.Amount;
    }

    public static implicit operator GrossAmount(decimal amount)
    {
        return new GrossAmount(amount, _globalTaxRate);
    }

    public static implicit operator NetAmount(GrossAmount grossAmount)
    {
        return decimal.Round(grossAmount.RemoveTax(_globalTaxRate), 2, MidpointRounding.AwayFromZero);
    }

    public override string ToString()
    {
        return this.Amount.ToString();
    }
}

TaxExtensions.cs

public static class TaxExtensions
{
    public static GrossAmount ApplyTax(this NetAmount netPrice, decimal taxRate)
    {
        return netPrice * (taxRate + 1);
    }

    public static NetAmount RemoveTax(this GrossAmount grossPrice, decimal taxRate)
    {
        return grossPrice / (taxRate + 1);
    }
}

Usage

// Only to set the global tax rate;
NetAmount init1 = new NetAmount(0.00m, 0.23m);
GrossAmount init2 = new GrossAmount(0.00m, 0.23m);

GrossAmount untaxedPrice = (NetAmount)2.13m;
NetAmount taxedPrice = (GrossAmount)2.00m;

Console.WriteLine(untaxedPrice + " " + taxedPrice);
Console.ReadLine();