解析十进制数而不丢失有效数字

Question

我需要将用户输入解析为数字并将其存储在十进制变量中。

对我来说，重要的是不要接受任何无法用十进制值正确表示的用户输入。

这对于非常大（或非常小的）数字非常有效，因为Parse方法在这些情况下会抛出OverflowException。

但是，当数字具有太多有效数字时，Parse方法将默默地返回截断（或四舍五入？）的值。

例如，解析1.23456789123456789123456789123（30 位有效数字）的结果等于1.2345678912345678912345678912（29 位有效数字）。

这是根据规范规定的，十进制值的精度为 28-29 位有效数字。

但是，我需要能够检测（并拒绝）解析时将被截断的数字，因为在我的情况下丢失有效数字是不可接受的。

解决这个问题的最佳方法是什么？

---

请注意，通过字符串比较进行预解析或后验证并不是一个简单的方法，因为我需要支持各种特定于文化的输入和各种数字样式（空格、千位分隔符、括号、指数语法、 ETC）。

因此，我正在寻找一种解决方案，而不重复 .NET 提供的解析代码。

---

我目前正在使用此解决方法来检测具有 28 个或更多有效数字的输入。虽然这有效，但它有效地将所有输入限制为最多 27 个有效数字（而不是 28-29）：

/// <summary>
///     Determines whether the specified value has 28 or more significant digits, 
///     in which case it must be rejected since it may have been truncated when 
///     we parsed it.
/// </summary>
static bool MayHaveBeenTruncated(decimal value)
{
    const string format = "#.###########################e0";
    string str = value.ToString(format, CultureInfo.InvariantCulture);
    return (str.LastIndexOf('e') - str.IndexOf('.')) > 27;
}

Answer 1

首先我要声明的是，没有“官方”解决方案。通常我不会依赖内部实施，所以我向您提供以下内容只是因为您说解决这个问题对您来说非常重要。

如果您查看参考源，您会发现所有解析方法都是在（不幸的是内部的）System.Number类中实现的。进一步调查，decimal相关方法是TryParseDecimal和ParseDecimal，它们都使用类似这样的方法

byte* buffer = stackalloc byte[NumberBuffer.NumberBufferBytes];
var number = new NumberBuffer(buffer);
if (TryStringToNumber(s, styles, ref number, numfmt, true))
{
   // other stuff
}                        

NumberBuffer另一个内部在哪里struct。关键是整个解析发生在TryStringToNumber方法内部，并且结果用于生成结果。我们感兴趣的是一个称为NumberBuffer 的字段precision，它由上述方法填充。

考虑到所有这些，我们可以生成一个类似的方法，只是在调用基本十进制方法后提取精度，以确保在进行后处理之前正常的验证/异常。所以方法会是这样的

static unsafe bool GetPrecision(string s, NumberStyles style, NumberFormatInfo numfmt)
{
    byte* buffer = stackalloc byte[Number.NumberBuffer.NumberBufferBytes];
    var number = new NumberBuffer(buffer);
    TryStringToNumber(s, styles, ref number, numfmt, true);
    return number.precision;
}

但请记住，这些类型及其方法都是内部的，因此很难应用正常的反射、委托或Expression基于技术。幸运的是，使用 编写这样的方法并不难System.Reflection.Emit。完整实现如下

public static class DecimalUtils
{
    public static decimal ParseExact(string s, NumberStyles style = NumberStyles.Number, IFormatProvider provider = null)
    {
        // NOTE: Always call base method first 
        var value = decimal.Parse(s, style, provider);
        if (!IsValidPrecision(s, style, provider))
            throw new InvalidCastException(); // TODO: throw appropriate exception
        return value;
    }

    public static bool TryParseExact(string s, out decimal result, NumberStyles style = NumberStyles.Number, IFormatProvider provider = null)
    {
        // NOTE: Always call base method first 
        return decimal.TryParse(s, style, provider, out result) && !IsValidPrecision(s, style, provider);
    }

    static bool IsValidPrecision(string s, NumberStyles style, IFormatProvider provider)
    {
        var precision = GetPrecision(s, style, NumberFormatInfo.GetInstance(provider));
        return precision <= 29;
    }

    static readonly Func<string, NumberStyles, NumberFormatInfo, int> GetPrecision = BuildGetPrecisionFunc();
    static Func<string, NumberStyles, NumberFormatInfo, int> BuildGetPrecisionFunc()
    {
        const BindingFlags Flags = BindingFlags.Public | BindingFlags.NonPublic;
        const BindingFlags InstanceFlags = Flags | BindingFlags.Instance;
        const BindingFlags StaticFlags = Flags | BindingFlags.Static;

        var numberType = typeof(decimal).Assembly.GetType("System.Number");
        var numberBufferType = numberType.GetNestedType("NumberBuffer", Flags);

        var method = new DynamicMethod("GetPrecision", typeof(int),
            new[] { typeof(string), typeof(NumberStyles), typeof(NumberFormatInfo) },
            typeof(DecimalUtils), true);

        var body = method.GetILGenerator();
        // byte* buffer = stackalloc byte[Number.NumberBuffer.NumberBufferBytes];
        var buffer = body.DeclareLocal(typeof(byte*));
        body.Emit(OpCodes.Ldsfld, numberBufferType.GetField("NumberBufferBytes", StaticFlags));
        body.Emit(OpCodes.Localloc);
        body.Emit(OpCodes.Stloc, buffer.LocalIndex);
        // var number = new Number.NumberBuffer(buffer);
        var number = body.DeclareLocal(numberBufferType);
        body.Emit(OpCodes.Ldloca_S, number.LocalIndex);
        body.Emit(OpCodes.Ldloc, buffer.LocalIndex);
        body.Emit(OpCodes.Call, numberBufferType.GetConstructor(InstanceFlags, null,
            new[] { typeof(byte*) }, null));
        // Number.TryStringToNumber(value, options, ref number, numfmt, true);
        body.Emit(OpCodes.Ldarg_0);
        body.Emit(OpCodes.Ldarg_1);
        body.Emit(OpCodes.Ldloca_S, number.LocalIndex);
        body.Emit(OpCodes.Ldarg_2);
        body.Emit(OpCodes.Ldc_I4_1);
        body.Emit(OpCodes.Call, numberType.GetMethod("TryStringToNumber", StaticFlags, null,
            new[] { typeof(string), typeof(NumberStyles), numberBufferType.MakeByRefType(), typeof(NumberFormatInfo), typeof(bool) }, null));
        body.Emit(OpCodes.Pop);
        // return number.precision;
        body.Emit(OpCodes.Ldloca_S, number.LocalIndex);
        body.Emit(OpCodes.Ldfld, numberBufferType.GetField("precision", InstanceFlags));
        body.Emit(OpCodes.Ret);

        return (Func<string, NumberStyles, NumberFormatInfo, int>)method.CreateDelegate(typeof(Func<string, NumberStyles, NumberFormatInfo, int>));
    }
}

自行承担使用风险 ：）