c#将格式化字符串(31.2k)转换回数字(31240)

本文关键字：转换 数字 31240 格式化 字符串 2k | 更新日期: 2023-09-27 18:11:17

假设我有这样的代码:

int i = 31240;
string Number = ((double)i / 1000).ToString("0.#k");

我得到这个结果作为Number: 31,2k的字符串

现在，我想做完全相反的事情，那就是把这个字符串"31,2k"并把它带回31240甚至31200，但我不知道怎么做…任何想法?

有人说那是不可能的。但最终我找到了实现目标的完美方法。我把解决方案贴出来给那些愿意知道的人。使用很简单，它允许进行两种转换:
  • 千，例:45831 <=> 45,8k <=> 45831
  • 百万，示例:123852376 <=> 123,5m <=> 123852376

c#将格式化字符串(31.2k)转换回数字(31240)

int i = (int)(Double.Parse(Number.Substring(0, Number.Length - 1)) * 1000);

我们用Number.Substring(0, Number.Length - 1)除去k，用Double.Parse变换为倍，再乘以1000，最后变换为int。东西的顺序很重要!我第一次做(int)Double.Parse(Number.Substring(0, Number.Length - 1)) * 1000，在乘法之前转换为int(所以我得到31000而不是31200)

我要补充一点，如果我必须写那段代码，如果我使用Decimal.Parse而不是Double.Parse，我会睡得更好(所以我肯定会反对浮点数的变幻莫测)

我将添加一个更好的方法:

int i2 = int.Parse(Number.Substring(0, Number.Length - 1).Replace(CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator, string.Empty)) * 100;

这个有趣多了。我们像在另一种方法中一样删除了k，但这次我们也从string中删除了,，并乘以100。

有趣的技巧是，我们不是简单地(在意大利俚语中是"bovinamente"，就像牛一样)将,替换为空字符串，而是获得当前的十进制分隔符(CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator)并将其替换为空字符串。

显然，如果我们在组成原始字符串时使用了另一种文化(例如总是很好的CultureInfo.InvariantCulture)，我们将使用它来获得NumberDecimalSeparator

我的解决方案是:

public class StringFromInt
{
    public enum FormatStyle
    {
        Kilo = 1000,
        Mega = 1000000
    }
    public int Number;
    public FormatStyle Format
    {
        get
        {
            switch (LimitValueBeforeConversion)
            {
                case 1000: return FormatStyle.Kilo;
                case 1000000: return FormatStyle.Mega;
                default:
                    throw new NotImplementedException("You must implement the code for this kind of value");
            }
        }
        set
        {
            if (value == FormatStyle.Kilo)
            {
                LimitValueBeforeConversion = 1000;
            }
            else if (value == FormatStyle.Mega)
            {
                LimitValueBeforeConversion = 1000000;
            }
        }
    }
    public int LimitValueBeforeConversion
    { get; set; }
    public static implicit operator int(StringFromInt s)
    {
        return s.Number;
    }
    public static implicit operator StringFromInt(int number)
    {
        StringFromInt s = new StringFromInt(number);
        return s;
    }
    #region Constructors
    public StringFromInt(int number, FormatStyle format)
    {
        this.Number = number;
        Format = format;
    }
    public StringFromInt(int number)
        : this(number, FormatStyle.Kilo)
    {
        if (number >= 1000000)
        {
            this.Format = FormatStyle.Mega;
        }
    }
    #endregion
    public override string ToString()
    {
        if (Number >= LimitValueBeforeConversion)
        {
            string formatString = "0.#k";
            switch (Format)
            {
                case FormatStyle.Kilo:
                    formatString = "0.#k";
                    break;
                case FormatStyle.Mega:
                    formatString = "0.#m";
                    break;
                default:
                    throw new NotImplementedException("You must implement the code for this kind of value");
            }
            return ((double)Number / LimitValueBeforeConversion).ToString(formatString);
        }
        else
        {
            return Number.ToString();
        }
    }
}

下面是一个测试程序:

class Program
{
    static void Main(string[] args)
    {
        int i = 31240;
        string StringRepresentation = ((double)i / 1000).ToString("0.#k");
        int resultBackWithParse = int.Parse(StringRepresentation.Substring(0, StringRepresentation.Length - 1).Replace(CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator, string.Empty)) * 100;
        Console.WriteLine("Base number: " + i.ToString());
        Console.WriteLine(new string('-', 35));
        Console.WriteLine("String representation: " + StringRepresentation);
        Console.WriteLine("Int representation With Int.Parse: " + resultBackWithParse.ToString());
        Console.WriteLine();
        StringFromInt MySolutionNumber = i;
        int resultBackWithStringFromInt = MySolutionNumber;
        Console.WriteLine("String representation With StringFromInt: " + MySolutionNumber.ToString());
        Console.WriteLine("Int representation With StringFromInt: " + resultBackWithStringFromInt);
        Console.WriteLine(new string('=', 35) + "'n");
        i = 123456789;
        StringFromInt MyNumber = 123456789;
        int resultBack = MyNumber;
        Console.WriteLine("Base number: " + i.ToString());
        Console.WriteLine(new string('-', 35));
        Console.WriteLine("String representation With StringFromInt: " + MyNumber);
        Console.WriteLine("Int representation With StringFromInt: " + resultBack);
        Console.ReadKey(true);
    }
}

你可以注意到，没有必要使用"new"初始化式，我的意思是没有必要这样做:

StringFromInt Number = new StringFromInt(YourNumber)

由于隐式操作符，您可以:

StringFromInt Number = YourNumber

我不知道，但我认为这是一个好的开始，你觉得呢?

无论如何，我设法做了我想做的，所以对于那些认为这是不可能的人，你看，这是可能的:-)

显然这可以改进:这个版本只适用于成千上万的用户。

问候

相关文章：