Найдите количество десятичных знаков в десятичном значении независимо от культуры

Поскольку ни один из предоставленных ответов не был достаточно хорош для преобразования магического числа "-0.01f" в десятичное ... то есть: GetDecimal((decimal)-0.01f);
Я могу только предположить, что колоссальный вирус мысленного пердения атаковал всех 3 года назад :)
Вот то, что кажется работающей реализацией этой злой и чудовищной проблемы, очень сложной проблемы подсчета десятичных знаков после точки - без строк, без культур, без необходимости считать биты и без необходимости читать математические форумы. просто простая математика для 3-го класса.

public static class MathDecimals
{
    public static int GetDecimalPlaces(decimal n)
    {
        n = Math.Abs(n); //make sure it is positive.
        n -= (int)n;     //remove the integer part of the number.
        var decimalPlaces = 0;
        while (n > 0)
        {
            decimalPlaces++;
            n *= 10;
            n -= (int)n;
        }
        return decimalPlaces;
    }
}

private static void Main(string[] args)
{
    Console.WriteLine(1/3m); //this is 0.3333333333333333333333333333
    Console.WriteLine(1/3f); //this is 0.3333333

    Console.WriteLine(MathDecimals.GetDecimalPlaces(0.0m));                  //0
    Console.WriteLine(MathDecimals.GetDecimalPlaces(1/3m));                  //28
    Console.WriteLine(MathDecimals.GetDecimalPlaces((decimal)(1 / 3f)));     //7
    Console.WriteLine(MathDecimals.GetDecimalPlaces(-1.123m));               //3
    Console.WriteLine(MathDecimals.GetDecimalPlaces(43.12345m));             //5
    Console.WriteLine(MathDecimals.GetDecimalPlaces(0));                     //0
    Console.WriteLine(MathDecimals.GetDecimalPlaces(0.01m));                 //2
    Console.WriteLine(MathDecimals.GetDecimalPlaces(-0.001m));               //3
    Console.WriteLine(MathDecimals.GetDecimalPlaces((decimal)-0.00000001f)); //8
    Console.WriteLine(MathDecimals.GetDecimalPlaces((decimal)0.0001234f));   //7
    Console.WriteLine(MathDecimals.GetDecimalPlaces((decimal)0.01f));        //2
    Console.WriteLine(MathDecimals.GetDecimalPlaces((decimal)-0.01f));       //2
}

Я бы, вероятно, использовал решение в ответе @ fixagon.

Однако, хотя структура Decimal не имеет метода для получения количества десятичных знаков, вы можете вызвать Decimal.GetBits для извлечения двоичного представления, затем используйте целочисленное значение и масштаб для вычисления количества десятичных знаков.

Это, вероятно, будет быстрее, чем форматирование в виде строки, хотя вам придется обрабатывать очень много десятичных знаков, чтобы заметить разницу.

Я оставлю реализацию в качестве упражнения.

Одно из лучших решений для определения количества цифр после десятичной точки показано в сообщении burn_LEGION.

Здесь я использую части из статьи форума STSdb: Количество цифр после десятичной точки.

В MSDN мы можем прочитать следующее объяснение:

"Десятичное число - это значение с плавающей запятой, состоящее из знака, числового значения, где каждая цифра в значении находится в диапазоне от 0 до 9, и коэффициента масштабирования, который указывает положение десятичной запятой с плавающей запятой, разделяющей целая и дробная части числового значения. "

А также:

«Двоичное представление десятичного значения состоит из 1-битового знака, 96-битного целого числа и коэффициента масштабирования, используемого для деления 96-битного целого числа и указания того, какая его часть является десятичной дробью. коэффициент масштабирования неявно представляет собой число 10, возведенное в степень в диапазоне от 0 до 28 ".

На внутреннем уровне десятичное значение представлено четырьмя целыми числами.

Существует общедоступная функция GetBits для получения внутреннего представления. Функция возвращает массив int []:

[__DynamicallyInvokable] 
public static int[] GetBits(decimal d)
{
    return new int[] { d.lo, d.mid, d.hi, d.flags };
}

Четвертый элемент возвращаемого массива содержит коэффициент масштабирования и знак. И, как сообщает MSDN, коэффициент масштабирования неявно представляет собой число 10, возведенное в степень в диапазоне от 0 до 28. Это именно то, что нам нужно.

Таким образом, на основе всех вышеперечисленных исследований мы можем построить наш метод:

private const int SIGN_MASK = ~Int32.MinValue;

public static int GetDigits4(decimal value)
{
    return (Decimal.GetBits(value)[3] & SIGN_MASK) >> 16;
}

Здесь SIGN_MASK используется для игнорирования знака. После логического и мы также сдвинули результат на 16 бит вправо, чтобы получить фактический масштабный коэффициент. Это значение, наконец, указывает количество цифр после десятичной точки.

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

Это решение выглядит лучшим, но подождите, это еще не все. Путем доступа к закрытым методам в C # мы можем использовать выражения для создания прямого доступа к полю флагов и избежать построения массива int:

public delegate int GetDigitsDelegate(ref Decimal value);

public class DecimalHelper
{
    public static readonly DecimalHelper Instance = new DecimalHelper();

    public readonly GetDigitsDelegate GetDigits;
    public readonly Expression<GetDigitsDelegate> GetDigitsLambda;

    public DecimalHelper()
    {
        GetDigitsLambda = CreateGetDigitsMethod();
        GetDigits = GetDigitsLambda.Compile();
    }

    private Expression<GetDigitsDelegate> CreateGetDigitsMethod()
    {
        var value = Expression.Parameter(typeof(Decimal).MakeByRefType(), "value");

        var digits = Expression.RightShift(
            Expression.And(Expression.Field(value, "flags"), Expression.Constant(~Int32.MinValue, typeof(int))), 
            Expression.Constant(16, typeof(int)));

        //return (value.flags & ~Int32.MinValue) >> 16

        return Expression.Lambda<GetDigitsDelegate>(digits, value);
    }
}

Этот скомпилированный код присваивается полю GetDigits. Обратите внимание, что функция получает десятичное значение как ref, поэтому фактическое копирование не выполняется - только ссылка на значение. Использовать функцию GetDigits из DecimalHelper просто:

decimal value = 3.14159m;
int digits = DecimalHelper.Instance.GetDigits(ref value);

Это самый быстрый способ получить количество цифр после десятичной точки для десятичных значений.

Опираться на внутреннее представление десятичных дробей - это не круто.

Как насчет этого:

    int CountDecimalDigits(decimal n)
    {
        return n.ToString(System.Globalization.CultureInfo.InvariantCulture)
                //.TrimEnd('0') uncomment if you don't want to count trailing zeroes
                .SkipWhile(c => c != '.')
                .Skip(1)
                .Count();
    }

вы можете использовать InvariantCulture

string priceSameInAllCultures = price.ToString(System.Globalization.CultureInfo.InvariantCulture);

другая возможность - сделать что-то вроде этого:

private int GetDecimals(decimal d, int i = 0)
{
    decimal multiplied = (decimal)((double)d * Math.Pow(10, i));
    if (Math.Round(multiplied) == multiplied)
        return i;
    return GetDecimals(d, i+1);
}

Большинство людей здесь, кажется, не подозревают, что decimal считает конечные нули важными для хранения и печати.

Таким образом, 0,1 м, 0,10 м и 0,100 м могут сравниваться как равные, они хранятся по-разному (как значение / масштаб 1/1, 10/2 и 100/3 соответственно) и будут напечатаны как 0,1, 0,10 и 0,100 соответственно. , автор ToString().

Таким образом, решения, которые сообщают о «слишком высокой точности», фактически сообщают о правильной точности на условиях decimal.

Кроме того, математические решения (например, умножение на 10), вероятно, будут очень медленными (десятичное число примерно в 40 раз медленнее, чем двойное для арифметики, и вы также не хотите смешивать числа с плавающей запятой, потому что это может привести к неточности ). Точно так же приведение к int или long в качестве средства усечения подвержено ошибкам (decimal имеет гораздо больший диапазон, чем любой из них - он основан на 96-битном целом числе).

Хотя это и не изящно как таковое, следующее, вероятно, будет одним из самых быстрых способов получить точность (при определении как «десятичные разряды, исключая конечные нули»):

public static int PrecisionOf(decimal d) {
  var text = d.ToString(System.Globalization.CultureInfo.InvariantCulture).TrimEnd('0');
  var decpoint = text.IndexOf('.');
  if (decpoint < 0)
    return 0;
  return text.Length - decpoint - 1;
}

Инвариантная культура гарантирует "." как десятичная точка, завершающие нули обрезаются, а затем просто нужно увидеть, сколько позиций осталось после десятичной точки (если она вообще есть).

Изменить: изменен тип возвращаемого значения на int

А вот еще один способ - использовать тип SqlDecimal, у которого есть свойство scale с подсчетом цифр справа от десятичной дроби. Преобразуйте десятичное значение в SqlDecimal, а затем откройте Scale.

((SqlDecimal)(decimal)yourValue).Scale

На данный момент почти все перечисленные решения выделяют память GC, что в значительной степени соответствует способу работы C #, но далеко не идеально в средах, критичных к производительности. (Те, которые не выделяют циклы использования, а также не принимают во внимание конечные нули.)

Таким образом, чтобы избежать GC Allocs, вы можете просто получить доступ к битам масштабирования в небезопасном контексте. Это может показаться хрупким, но согласно справочному источнику Microsoft, структура макет десятичной дроби - Последовательный и даже имеет комментарий, чтобы не менять порядок полей:

    // NOTE: Do not change the order in which these fields are declared. The
    // native methods in this class rely on this particular order.
    private int flags;
    private int hi;
    private int lo;
    private int mid;

Как видите, первое int здесь - это поле флагов. Из документации и, как упоминалось в других комментариях здесь, мы знаем, что только биты из 16-24 кодируют масштаб и что нам нужно избегать 31-го бита, который кодирует знак. Поскольку int имеет размер 4 байта, мы можем безопасно сделать это:

internal static class DecimalExtensions
{
  public static byte GetScale(this decimal value)
  {
    unsafe
    {
      byte* v = (byte*)&value;
      return v[2];
    }
  }
}

Это должно быть наиболее производительное решение, поскольку для массива байтов или преобразований ToString не используется сборщик мусора. Я тестировал его на .Net 4.x и .Net 3.5 в Unity 2019.1. Если есть какие-либо версии, в которых это не удается, сообщите мне.

Изменить:

Спасибо @Zastai за напоминание о возможности использования явного макета структуры для практического достижения той же логики указателя за пределами небезопасного кода:

[StructLayout(LayoutKind.Explicit)]
public struct DecimalHelper
{
    const byte k_SignBit = 1 << 7;

    [FieldOffset(0)]
    public decimal Value;

    [FieldOffset(0)]
    public readonly uint Flags;
    [FieldOffset(0)]
    public readonly ushort Reserved;
    [FieldOffset(2)]
    byte m_Scale;
    public byte Scale
    {
        get
        {
            return m_Scale;
        }
        set
        {
            if(value > 28)
                throw new System.ArgumentOutOfRangeException("value", "Scale can't be bigger than 28!")
            m_Scale = value;
        }
    }
    [FieldOffset(3)]
    byte m_SignByte;
    public int Sign
    {
        get
        {
            return m_SignByte > 0 ? -1 : 1;
        }
    }
    public bool Positive
    {
        get
        {
            return (m_SignByte & k_SignBit) > 0 ;
        }
        set
        {
            m_SignByte = value ? (byte)0 : k_SignBit;
        }
    }
    [FieldOffset(4)]
    public uint Hi;
    [FieldOffset(8)]
    public uint Lo;
    [FieldOffset(12)]
    public uint Mid;

    public DecimalHelper(decimal value) : this()
    {
        Value = value;
    }

    public static implicit operator DecimalHelper(decimal value)
    {
        return new DecimalHelper(value);
    }

    public static implicit operator decimal(DecimalHelper value)
    {
        return value.Value;
    }
}

Чтобы решить исходную проблему, вы можете удалить все поля, кроме Value и Scale, но, возможно, кому-то будет полезно иметь их все.

Я использую что-то очень похожее на ответ Клемента:

private int GetSignificantDecimalPlaces(decimal number, bool trimTrailingZeros = true)
{
  string stemp = Convert.ToString(number);

  if (trimTrailingZeros)
    stemp = stemp.TrimEnd('0');

  return stemp.Length - 1 - stemp.IndexOf(
         Application.CurrentCulture.NumberFormat.NumberDecimalSeparator);
}

Не забудьте использовать System.Windows.Forms для доступа к Application.CurrentCulture.

Вчера я написал краткий небольшой метод, который также возвращает количество десятичных знаков без необходимости полагаться на какие-либо разбиения строк или культуры, что идеально:

public int GetDecimalPlaces(decimal decimalNumber) { // 
try {
    // PRESERVE:BEGIN
        int decimalPlaces = 1;
        decimal powers = 10.0m;
        if (decimalNumber > 0.0m) {
            while ((decimalNumber * powers) % 1 != 0.0m) {
                powers *= 10.0m;
                ++decimalPlaces;
            }
        }
return decimalPlaces;

Я использую в своем коде следующий механизм

  public static int GetDecimalLength(string tempValue)
    {
        int decimalLength = 0;
        if (tempValue.Contains('.') || tempValue.Contains(','))
        {
            char[] separator = new char[] { '.', ',' };
            string[] tempstring = tempValue.Split(separator);

            decimalLength = tempstring[1].Length;
        }
        return decimalLength;
    }

десятичный ввод = 3,376; var instring = input.ToString ();

вызвать GetDecimalLength (instring)

Используя рекурсию, вы можете:

private int GetDecimals(decimal n, int decimals = 0)  
{  
    return n % 1 != 0 ? GetDecimals(n * 10, decimals + 1) : decimals;  
}

В качестве метода десятичного расширения, учитывающего:

• Разные культуры
• Целые числа
• Отрицательные числа
• Завершающий набор нулей в десятичном разряде (например, 1,2300M вернет 2, а не 4)

public static class DecimalExtensions
{
    public static int GetNumberDecimalPlaces(this decimal source)
    {
        var parts = source.ToString(CultureInfo.InvariantCulture).Split('.');

        if (parts.Length < 2)
            return 0;

        return parts[1].TrimEnd('0').Length;
    }
}

Можешь попробовать:

int priceDecimalPlaces =
        price.ToString(System.Globalization.CultureInfo.InvariantCulture)
              .Split('.')[1].Length;

Предлагаю воспользоваться этим методом:

    public static int GetNumberOfDecimalPlaces(decimal value, int maxNumber)
    {
        if (maxNumber == 0)
            return 0;

        if (maxNumber > 28)
            maxNumber = 28;

        bool isEqual = false;
        int placeCount = maxNumber;
        while (placeCount > 0)
        {
            decimal vl = Math.Round(value, placeCount - 1);
            decimal vh = Math.Round(value, placeCount);
            isEqual = (vl == vh);

            if (isEqual == false)
                break;

            placeCount--;
        }
        return Math.Min(placeCount, maxNumber); 
    }