Обновить

Хорошо, после некоторого расследования и во многом благодаря полезным ответам, предоставленным Джоном и Хансом, это то, что я смог собрать. Пока я думаю, что это работает хорошо. Я бы, конечно, не стал ставить свою жизнь на полную справедливость.

public static int GetSignificantDigitCount(this decimal value)
{
    /* So, the decimal type is basically represented as a fraction of two
     * integers: a numerator that can be anything, and a denominator that is 
     * some power of 10.
     * 
     * For example, the following numbers are represented by
     * the corresponding fractions:
     * 
     * VALUE    NUMERATOR   DENOMINATOR
     * 1        1           1
     * 1.0      10          10
     * 1.012    1012        1000
     * 0.04     4           100
     * 12.01    1201        100
     * 
     * So basically, if the magnitude is greater than or equal to one,
     * the number of digits is the number of digits in the numerator.
     * If it's less than one, the number of digits is the number of digits
     * in the denominator.
     */

    int[] bits = decimal.GetBits(value);

    if (value >= 1M || value <= -1M)
    {
        int highPart = bits[2];
        int middlePart = bits[1];
        int lowPart = bits[0];

        decimal num = new decimal(lowPart, middlePart, highPart, false, 0);

        int exponent = (int)Math.Ceiling(Math.Log10((double)num));

        return exponent;
    }
    else
    {
        int scalePart = bits[3];

        // Accoring to MSDN, the exponent is represented by
        // bits 16-23 (the 2nd word):
        // http://msdn.microsoft.com/en-us/library/system.decimal.getbits.aspx
        int exponent = (scalePart & 0x00FF0000) >> 16;

        return exponent + 1;
    }
}

Нет. Я все это тщательно проверил. Вот несколько примеров входов / выходов:

Value          Precision
0              1 digit(s).
0.000          4 digit(s).
1.23           3 digit(s).
12.324         5 digit(s).
1.2300         5 digit(s).
-5             1 digit(s).
-5.01          3 digit(s).
-0.012         4 digit(s).
-0.100         4 digit(s).
0.0            2 digit(s).
10443.31       7 digit(s).
-130.340       6 digit(s).
-80.8000       6 digit(s).

Используя этот код, я полагаю, что достигну своей цели, сделав что-то вроде этого:

public static decimal DivideUsingLesserPrecision(decimal x, decimal y)
{
    int xDigitCount = x.GetSignificantDigitCount();
    int yDigitCount = y.GetSignificantDigitCount();

    int lesserPrecision = System.Math.Min(xDigitCount, yDigitCount);

    return System.Math.Round(x / y, lesserPrecision);
}

Я еще не закончил работать над этим. Любой, кто хочет поделиться мыслями: это было бы очень признательно!

Исходный вопрос

Предположим, я написал этот код:

decimal a = 1.23M;
decimal b = 1.23000M;

Console.WriteLine(a);
Console.WriteLine(b);

Выше будет выведено:

1.23
1.23000

Я считаю, что это также работает, если я использую ] decimal.Parse ("1.23") для a и decimal.Parse ("1.23000") для b (что означает, что этот вопрос относится к случаи, когда программа получает ввод пользователя).

Итак, очевидно, что десятичное значение каким-то образом «осведомлено» о том, что я назову его точностью . Тем не мение, Я не вижу членов в типе decimal , которые предоставляют какой-либо способ доступа к нему, кроме самого ToString .

Предположим, я хотел умножить два десятичных значения и обрезать результат до точности менее точного аргумента. Другими словами:

decimal a = 123.4M;
decimal b = 5.6789M;

decimal x = a / b;

Console.WriteLine(x);

Вышеупомянутые результаты:

21.729560302171195125816619416

Я спрашиваю: как я могу написать метод, который бы возвращал 21,73 вместо этого (поскольку 123,4M имеет четыре значащие цифры)?

Для ясности: я понимаю, что могу вызвать ToString для обоих аргументов, подсчитать значащие цифры в каждой строке и использовать это число для округления результата вычисления. Я ищу другой способ, если возможно.

(Я также понимаю, что в большинстве сценариев, где вы ' при работе со значащими цифрами вам, вероятно, не нужно использовать десятичный тип . Но я спрашиваю, потому что, как я упоминал в начале, десятичный тип появляется , чтобы включать информацию о точности, тогда как double нет, поскольку Я знаю.)