C# 十进制（字符串类型）在最后一个字符处舍入

这是一个解决方案：

    public static decimal RoundLastChar(this string input)
    {
        decimal inputDecimal = Convert.ToDecimal(input, new CultureInfo("en-US"));
        int decimalPlaces = BitConverter.GetBytes(decimal.GetBits(inputDecimal)[3])[2];
        if (decimalPlaces == 0) return inputDecimal;
        decimal result = Math.Round(inputDecimal, decimalPlaces - 1, MidpointRounding.AwayFromZero).Normalize();
        return result;
    }

    public static decimal Normalize(this decimal value)
    {
        return value / 1.000000000000000000000000000000000m;
    }

获取小数位数的方法来自此处，归一化小数的方法来自此处。

因为您的输入值是字符串类型，所以我会用它来确保输入是有效的数字。decimal.TryParsedecimal

然后，您可以尝试使用一个简单的算法从输入中计算浮点长度，然后执行Math.Round

static decimal RoundFirstSignificantDigit(string input) {
    
    decimal significantDigit;
    if (!decimal.TryParse(input,out significantDigit))
    {
        throw new ArgumentException("Invalid input!!");
    }
    var floatLength = input.Split('.')[1].Length;

    return Math.Round(significantDigit, floatLength - 1, MidpointRounding.AwayFromZero);
}

C# 联机

编辑

如果你的输入有大小数，由于C#十进制只允许&之间的范围，目前不支持像Java那样。±1.0 × 10-28 to ±7.9228 × 1028 BigDecimal

我认为有两种方法可以做到这一点。

1. 制作自己的圆形逻辑。BigDecimal
2. 您可以尝试使用支持您从 java 调用的 IKVM 库。BigDecimal

您可以简单地通过IKVM实现您的期望。

static string RoundFirstSignificantDigit(string input) {
    BigDecimal significantDigit = new BigDecimal(input);
    var floatLength = input.Split('.')[1].Length;
    return significantDigit.setScale(floatLength - 1, BigDecimal.ROUND_HALF_UP).toString().TrimEnd('0');
}

C# 联机

嗯，这很棘手，因为小数点后 2000 位你不能使用 .所以也许有比这更简单的东西，但它可能对你有用（.NET 小提琴演示）：decimal

public static string RoundLongNumber(this string input)
{
    if (!ValidLongNumber(input, out bool isInteger) || isInteger) return input;
    int index = input.IndexOf('.');
    string part1 = input.Remove(index);
    string part2 = input.Substring(index + 1);
    StringBuilder sb = new StringBuilder(part2);

    while(true)
    {
        if (LastInt() <= 4)
        {
            return BuildNumber();
        }

        sb.Length = sb.Length - 1; // remove last
        int lastInt = LastInt() + 1;
        while (lastInt == 10)
        {
            sb.Length = sb.Length - 1;
            if (sb.Length == 0)
            {
                // just integer remaining
                int num = int.Parse(part1);
                return (++num).ToString();
            }
            lastInt = LastInt() + 1;
        }

        sb[sb.Length - 1] = (char)(lastInt + '0');
        if (lastInt != 9) return BuildNumber();
    }

    int LastInt() => sb[sb.Length - 1] - '0';
    string BuildNumber() => part1 + "." + sb.ToString();
}

private static bool ValidLongNumber(string number, out bool isInteger)
{
    isInteger = true;
    if (string.IsNullOrWhiteSpace(number)) return false;
    int pointCount = 0;
    foreach(char c in number)
    {
        bool isDigit = char.IsDigit(c);
        bool isPoint = c == '.';
        if (!isDigit) isInteger = false;
        if (isPoint) pointCount++;
        if(pointCount > 1 || (!isPoint && !isDigit)) return false;
    }
    return true;
}

下面是你的示例：

public static void Main()
{
    var strings = new List<string> {
    "123.99999", // must become 124
    "129.99999", // must become 130
    "123.823467283762378",  // must become 123.82346728376238
    "123.823467283762398",  // must become 123.8234672837624 (notice the last 0 has gone)
    "123.09999999", // must become 123.1 (notice no trailing zeros needed..)
    "122.00000009", // must become 122.0000001
    "124.81379281", // must become simply 124.8137928 >>> Why? Should remain same
    "129.07872345", // must become 129.0787235
    "129.07872344", // must become 129.0787234        >>> Why? Should remain same
    };

    IEnumerable<string> results = strings.Select(s => s.RoundLongNumber());
    foreach(var res in results)
    {
        Console.WriteLine(res);
    }
}

请注意，两个结果是不同的，但要么你没有解释该规则，要么你的预期是错误的：

124.81379281 // must become simply 124.8137928
129.07872344 // must become 129.0787234

为什么？根据我的理解，两者应该保持不变。