Question

假设我有这段代码：

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

我将这个结果作为数字的字符串得到：31,2k

现在，我想做的恰恰相反，就是拿这个字符串“31,2k”然后把它带回31240甚至31200，但我不知道怎么做...... 有什么想法吗？

有人说这是不可能的。但最后我找到了实现目标的完美方式。我为那些愿意知道的人发布解决方案。使用很简单，它允许进行两种转换：

数千，例如：45831＆lt; =＆gt; 45,8k＆lt; =＆gt; 45831
百万，例如：123852376＆lt; =＆gt; 123,5m＆lt; =＆gt; 123852376

Answer 1

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

我们将k移除Number.Substring(0, Number.Length - 1)，将其转换为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”，就像bovines那样）用空字符串替换,，我们得到当前的小数分隔符（CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator）和我们用空字符串替换THAT。

显然，我们在撰写原始字符串时使用了另一种文化（例如总是很好的CultureInfo.InvariantCulture）我们会用它来获取NumberDecimalSeparator

Answer 2

以下是我遇到的解决方案：

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

我不知道，但我认为这是一个好的开始，你怎么看？

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

显然这可以改进：这个版本仅适用于数千和数百万。

问候

C＃将格式化字符串（31.2k）转换回数字（31240）

2 个答案: