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

Question

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

不接受任何不能用 decimal 值正确表示的用户输入对我来说很重要。

这适用于非常大(或非常小)的数字，因为在这些情况下 Parse 方法会抛出 OverflowException。

但是，当一个数字有太多有效数字时，Parse 方法将返回一个截断(或四舍五入？)的值。

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

这是根据 specification 的说法，decimal 值的精度为 28-29 位有效数字。

但是，我需要能够检测(并拒绝)在解析时将被截断的数字，因为在我的情况下丢失有效数字是 Not Acceptable 。

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

---

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

因此，我正在寻找一种解决方案，而无需复制 .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 中实现。类(class)。进一步调查，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;
}

但请记住，这些类型及其方法都是内部类型，因此很难应用正常的反射、委托(delegate)或基于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>));
    }
}

使用它需要您自担风险:)