Question

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

对我来说，不接受任何无法用decimal值正确表示的用户输入非常重要。

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

但是，当一个数字的有效位数太多时，Parse方法将静默返回一个截断的（或舍入的？）值。

例如，解析1.23456789123456789123456789123（30位有效数字）会产生等于1.2345678912345678912345678912（29位有效数字）的值。

这是根据specification表示decimal值的精确度为28-29个有效数字。

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

最好的方法是什么？

请注意，通过字符串比较进行预解析或后验证不是一种简单的方法，因为我需要支持各种特定于文化的输入和各种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

假设输入是一个字符串并且已经验证为数字，则可以使用String.Split：

text = text.Trim().Replace(",", "");
bool neg = text.Contains("-");
if (neg) text = text.Replace("-", "");
while (text.Substring(0, 1) == 0 && text.Substring(0, 2) != "0." && text != "0")
    text = text.Substring(1);
if (text.Contains("."))
{
    while (text.Substring(text.Length - 1) == "0")
        text = text.Substring(0, text.Length - 1);
}
if (text.Split(".")[0].Length + text.Split(".")[1].Length + (neg ? 1 : 0) <= 29)
    valid = true;

您可以覆盖或替换Parse并包含此检查。

Answer 2

问题在于，当您进行对话时会进行四舍五入，即如果小数超过28，则Decimal myNumber = Decimal.Parse(myInput)将始终以舍入数字返回。

你不想创建一个大的解析器，所以我要做的是将输入字符串值与新的十进制值作为字符串进行比较：

//This is the string input from the user
string myInput = "1.23456789123456789123456789123";

//This is the decimal conversation in your application
Decimal myDecimal = Decimal.Parse(myInput);

//This is the check to see if the input string value from the user is the same 
//after we parsed it to a decimal value. Now we need to parse it back to a string to verify
//the two different string values:
if(myInput.CompareTo(myDecimal.ToString()) == 0)
    Console.WriteLine("EQUAL: Have NOT been rounded!");
else
    Console.WriteLine("NOT EQUAL: Have been rounded!");

这样C＃将处理所有数字，你只需要快速检查。

Answer 3

你应该看看BigRational的影响。它不是（还是？）.Net框架的一部分，但它是BigInteger类的兼容性，并提供了一个TryParse方法。这样您就可以比较解析后的BigRational是否等于解析的小数。

Answer 4

首先让我说明没有“官方”解决方案。通常情况下，我不会依赖内部实施，所以我只是因为你说解决问题对你来说非常重要。

如果您查看参考源，您将看到所有解析方法都在（不幸的是内部）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方法内，结果用于产生结果。我们感兴趣的是名为precision的{{3}}字段，该字段由上述方法填充。

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

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>));
    }
}

自担风险使用它：）

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

4 个答案: