两倍于10 ^ x的结果是int64吗？

Question

I have a variable representing a quantity in some given unit:

enum Unit
{
  Single,
  Thousand,
  Million,
  Billion,
  Trillion
}

public class Quantity()
{

  public double number;
  public Unit numberUnit;

  public Int64 GetNumberInSingleUnits()
  {
    // ???
  }

}

For example, imagine

var GDP_Of_America = new Quantiy { number = 16.66, numberUnit = Unit.Trillion };
Int64 gdp = GDP_Of_America.GetNumberinSingleUnits();  // should return 16,660,000,000,000

My question is basically - how can I implement the "GetNumberInSingleUnits" function? I can't just multiply with some UInt64 factor, eg

        double num = 0.5;
        UInt64 factor = 1000000000000;

        var result = num * factor; // won't work! results in double

As the regular numeric operations reslt in a double, but the result may be larger than the range of valid doubles.

How could I do this conversion?

ps, I know the class "Quantity" is not a great way to store information - but this is bound by the input data of my application, which is in non-single (eg millions, billions etc) units.

Answer 1

Like I said, decimal s can help you here:

public enum Unit
{
    Micro = -6, Milli = -3, Centi = -2, Deci = -1,
    One /* Don't really like this name */, Deca, Hecto, Kilo, Mega = 6, Giga = 9
}

public struct Quantity
{
    public decimal Value { get; private set; }

    public Unit Unit { get; private set; }

    public Quantity(decimal value, Unit unit) : 
        this()
    {
        Value = value;
        Unit = unit;
    }

    public decimal OneValue /* This one either */
    {
        get
        {
            return Value * (decimal)Math.Pow(10, (int)Unit);
        }
    }
}

With decimal s you won't lose a lot of precision until after you decide to convert them to long (and beware of over/underflows).

Answer 2

Anton's answer seems like a good solution. Just for the sake of discussion, another potential way.

I don't like this one at all as it seems very messy; However I think this might avoid imprecisions, if these ever turned out to be an issue with decimals.

public Int64 GetAsInt64(double number)
{
    // Returns 1 for single units, 3 for thousands, 6 for millions, etc.
    uint e = GetFactorExponent();

    // Converts to scientific notation
    // e.g. number = -1.2345, unit millions to "-1.2345e6"
    string str = String.Format("{0:#,0.###########################}", number) + "e" + e;

    // Parses scientific notation into Int64
    Int64 result = Int64.Parse(str, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent | NumberStyles.AllowThousands);
    return result;
}