Определите десятичную точность входного числа

Я думаю, вам следует просто сделать то, что вы предложили, - использовать позицию десятичной точки. Очевидным недостатком может быть то, что вам придется самому думать об интернационализации.

var decimalSeparator = NumberFormatInfo.CurrentInfo.CurrencyDecimalSeparator;

var position = input.IndexOf(decimalSeparator);

var precision = (position == -1) ? 0 : input.Length - position - 1;

// This may be quite unprecise.
var result = Math.Pow(0.1, precision);

Есть еще одна вещь, которую вы можете попробовать - тип Decimal хранит значение внутренней точности. Поэтому вы можете использовать Decimal.TryParse() и проверить возвращаемое значение. Возможно, алгоритм синтаксического анализа поддерживает точность ввода.

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

ОБНОВЛЕНИЕ

Разбор на десятичную дробь работает. Дополнительную информацию см. В Decimal.GetBits().

var input = "123.4560";

var number = Decimal.Parse(input);

// Will be 4.
var precision = (Decimal.GetBits(number)[3] >> 16) & 0x000000FF;

Отсюда использование Math.Pow(0.1, precision) просто.

ОБНОВЛЕНИЕ 2

Использование decimal.GetBits () выделит массив int[]. Если вы хотите избежать распределения, вы можете использовать следующий вспомогательный метод, который использует явную структуру макета, чтобы получить масштаб непосредственно из десятичного значения:

static int GetScale(decimal d)
{
    return new DecimalScale(d).Scale;
}

[StructLayout(LayoutKind.Explicit)]
struct DecimalScale
{
    public DecimalScale(decimal value)
    {
        this = default;
        this.d = value;
    }

    [FieldOffset(0)]
    decimal d;

    [FieldOffset(0)]
    int flags;

    public int Scale => (flags >> 16) & 0xff;
}

Просто интересно, есть ли более простое решение.

No.

Использовать строку:

string[] res = inputstring.Split('.');
int precision = res[1].Length;

Поскольку ваши последние примеры показывают, что конечные нули важны, я бы исключил любое численное решение и перешел к строковым операциям.

Нет, более простого решения нет, надо проверить строку. Если вы конвертируете "4500" и "4500.00" в числа, они оба становятся значением 4500, поэтому вы не можете определить, сколько цифр, не являющихся значениями, было за десятичным разделителем.

Интересно отметить, что Decimal пытается сохранить точность, введенную пользователем. Например,

Console.WriteLine(5.0m);
Console.WriteLine(5.00m);
Console.WriteLine(Decimal.Parse("5.0"));
Console.WriteLine(Decimal.Parse("5.00"));

Имеет выход:

5.0
5.00
5.0
5.00

Если ваша мотивация в отслеживании точности ввода обусловлена ​​исключительно соображениями ввода и вывода, этого может быть достаточно для решения вашей проблемы.

Работать со строкой достаточно просто.

Если нет "." в строке верните 1.

В противном случае верните «0.», за которым следует n-1 «0», за которым следует одна «1», где n - длина строки после десятичной точки.

Вот возможное решение с использованием строк;

static double GetPrecision(string s)
{ 
    string[] splitNumber = s.Split('.');
    if (splitNumber.Length > 1)
    {
        return 1 / Math.Pow(10, splitNumber[1].Length);
    }
    else
    {
        return 1;
    }
}

Здесь есть вопрос; Рассчитайте System.Decimal Precision and Scale, который, похоже, может быть интересен, если вы хотите вникнуть в это еще раз.