C#

public enum ENRateType { Dollar, Percent }

public class Rate
{
    public ENRateType RateType;
    public double Rate;
}

Widget          $12.00
Shipping        $3.95
Subtotal        $15.95
Tax             8.875%
Total           $30.11

Collin Jasnoch wrote:

Because he has not stated his reason for layers but is trying to use it. That is
the point.

Collin Jasnoch wrote:

I have seen cases where an empty interface is even used. It is not over
engineering. It is creating a base API.
 

By what the OP was an
interface is exactly what should be used.

public class Rate
{
	public double Value; // Holds either the dollar or percentage value
	
	public override string ToString ()
	{
		string typeName = GetType().Name;
		// removes the prefix, if present
		if (typeName.StartsWith(typeof(Rate).Name))
			typeName = typeName.Substring(typeof(Rate).Name.Length);
		return typeName;
	}
}
// Console.WriteLine(myTransactionLine.Amount);
// would then result in "Dollar" as output

Bastard Programmer from Hell
if you can't read my code, try converting it here[^]

hpjchobbes wrote:

Thanks for the code! That would work as a temporary solution, I think!

Bastard Programmer from Hell
if you can't read my code, try converting it here[^]

hpjchobbes wrote:

if(myTransactionLine.Amount.GetType() == typeof(RateDollar))

SledgeHammer01 wrote:

so it should just be a single class with an enum

Quote:

I have a class that contains a double value. This double could represent a dollar value or it could represent a percentage value. Only one or the other, it will never have both. At runtime, I will need to be able to tell what type of value this is. Here is what I came up with, which appears to work, but if there is a better way, I would prefer that.

Collin Jasnoch wrote:

That is not exactly what his post states

Rate r = new Rate(ENRateType.Dollar, 5.58d);
//r.ToRateString() would display $5.58

public enum ENRateType { Dollar, Percent }

public class Rate
{
    public Rate()
    {
        RateType = ENRateType.Dollar;
        Value = 0d;
    }

    public Rate(ENRateType rateType, double value) : this()
    {
        RateType = rateType;
        Value = value;
    }

    public ENRateType RateType {get; internal set;}
    public double Value { get; internal set; }

    public string ToRateString()
    {
        if (RateType == ENRateType.Dollar) return "$" + Value.ToString("0.00");
        return Value.ToString("0.000") + "%";
    }

}

Trak4Net wrote:

stick with simplicity

interface Rate
{
    double getValue();
}

class DollarRate : Rate
{
    double rawval; //the actual value

    internal double getValue()
    {
        return rawval * 6; //format in the way you want
    }
}

class PercetageRate : Rate
{
    double rawval; //again, the value

    internal double getValue()
    {
        return rawval; //I just use the raw value for percentage
    }
}

class EuroRate : Rate
{
    double rawval;

    internal double getValue()
    {
        return rawval * 9; //some other rate
    }
}

void Main()
{
    if(myTransactionLine.Amount is DollarRate)
    {
        //do dollar
    }
    else if(myTransactionLine.Amount is PercetageRate)
    {
        //do percentage
    }
    //continue...
}

static class Rates
{
    //you can use whatever datatype you want, I choose byte since its 4 times smaller than int and can hold 256 cominations (including 0). You could also use chars: DOLLAR = '$', PERCENTAGE = '%', EURO = '€' etc...
    public const byte DOLLAR = 0;
    public const byte PERCENTAGE = 1;
    public const byte EURO = 2;
    //add more constants for more rates
}

class Rate
{
    double value;
    byte type; //the type of the rate

    internal double Value
    {
        get { return value; }
    }
  
    internal byte Type
    {
        get { return type; }
    }
}

void Main()
{
    if(myTransactionLine.Amount.Type == Rates.DOLLAR)
    {
        //do dollar
    }
    else if(myTransactionLine.Amount is Rates.PERCENTAGE)
    {
        //do percentage
    }
    //continue...
}

interface ISurcharge {
 double GetAmount(Order order);
 string Name { get; }
}

class FixedSurcharge : ISurcharge {
 private double amount;
 public string Name { get; private set; }
 public FixedSurcharge(string name, double amount) { Name = name; this.amount = amount; }
 public double GetAmount(Order order) { return amount; }
}

class PercentageSurcharge : ISurcharge {
 private double percentage;
 public string Name { get; private set; }
 public PercentageSurcharge (string name, double percentage) { Name = name; this.percentage = percentage; }
 public double GetAmount(Order order) { return percentage * 0.01 * order.TotalValue; }
}

void placeOrder(Order order){
 foreach(OrderItem item in order.Items) { addBillItem(item.Name, item.Value); }
 addSurcharge(new PercentageSurcharge("VAT", 20), order);
 addSurcharge(new FixedSurcharge("Shipping", 2.50), order);
}

void addSurcharge(ISurcharge surcharge, Order order){
 addBillItem(surcharge.Name, surcharge.GetAmount(order));
}