String.Format для получения "2.4k" от "2400"

Question

Есть ли способ использовать String.Format для преобразования чисел в числовые / символьные представления.

Например

2400 -> 2.4k
2,600,000 -> 2.6m

Answer 1

Я предоставляю пример кода.Пожалуйста, попробуйте сделать это по-своему

private static string ToEngineeringNotation(this double d)
    {
        double exponent = Math.Log10(Math.Abs(d));
        if (Math.Abs(d) >= 1)
        {
            switch ((int)Math.Floor(exponent))
            {
                case 0: case 1: case 2:
                    return d.ToString();
                case 3: case 4: case 5:
                    return (d / 1e3).ToString() + "k";
                case 6: case 7: case 8:
                    return (d / 1e6).ToString() + "M";
                case 9: case 10: case 11:
                    return (d / 1e9).ToString() + "G";
                case 12: case 13: case 14:
                    return (d / 1e12).ToString() + "T";
                case 15: case 16: case 17:
                    return (d / 1e15).ToString() + "P";
                case 18: case 19: case 20:
                    return (d / 1e18).ToString() + "E";
                case 21: case 22: case 23:
                    return (d / 1e21).ToString() + "Z";
                default:
                    return (d / 1e24).ToString() + "Y";
            }
        }
        else if (Math.Abs(d) > 0)
        {
            switch ((int)Math.Floor(exponent))
            {
                case -1: case -2: case -3:
                    return (d * 1e3).ToString() + "m";
                case -4: case -5: case -6:
                    return (d * 1e6).ToString() + "μ";
                case -7: case -8: case -9:
                    return (d * 1e9).ToString() + "n";
                case -10: case -11: case -12:
                    return (d * 1e12).ToString() + "p";
                case -13: case -14: case -15:
                    return (d * 1e15).ToString() + "f";
                case -16: case -17: case -18:
                    return (d * 1e18).ToString() + "a";
                case -19: case -20: case -21:
                    return (d * 1e21).ToString() + "z";
                default:
                    return (d * 1e24).ToString() + "y";
            }
        }
        else
        {
            return "0";
        }
    }

Answer 2

Я написал это для вас.

string onem = intToSimple(1000000);
string onek = intToSimple(1000);
private string intToSimple(int number)
{
    if(val > 1000000000000)
        return (val / 1000000000000).ToString("0.00") + "tr";
    else if(val > 1000000000)
        return (val / 1000000000).ToString("0.00") + "b";
    else if(val > 1000000)
        return (val / 1000000).ToString("0.00") + "m";
    else if(val > 1000)
        return (val / 1000).ToString("0.00") + "k";
    else
        return value.ToString("0.00");
}

Answer 3

Нет, я не верю, что есть строка формата, которая сделает это за вас.

Вы можете найти сторонние библиотеки для этого, и я знаю, что есть встроенные подпрограммы Win32 для преобразования размер файла в таком представлении, но это вполне может использовать 1024, а не 1000 для "базы" K / M / и т.д. Этот ответ переполнения стека показывает некоторый код C # для него, но я уверен, что что-то есть и в платформе ... и, как я уже сказал, это нацелено на размеры файлов, которые могут или не могут быть тем, что выхочу.

Answer 4

Вы также можете попробовать следующее:

Преобразуйте ваш номер в строку в научном формате: 2400 -> 2,4e + 003; 2 600 000 -> 2,6e + 006

Затем замените показатель степени на желаемый префикс SI (например, e + 003 -> k, e + 006 -> M, e-009 -> n)

Для этого я создал следующее расширение:

using System;
using System.Globalization;

/// <summary>
/// Si prefixed string conversion class
/// </summary>
public static class SIPrefixedString
{
    /// <summary>
    /// converts the value into a string with SI prefix
    /// </summary>
    /// <param name="value">The value.</param>
    /// <returns>si prefixed string</returns>
    public static string ToSIPrefixedString(this double value)
    {
        string stringValue = value.ToString("#E+00", CultureInfo.InvariantCulture);
        string[] stringValueParts = stringValue.Split("E".ToCharArray());
        int mantissa = Convert.ToInt32(stringValueParts[0], CultureInfo.InvariantCulture);
        int exponent = Convert.ToInt32(stringValueParts[1], CultureInfo.InvariantCulture);
        while (exponent % 3 != 0)
        {
            mantissa *= 10;
            exponent -= 1;
        }

        string prefixedValue = mantissa.ToString(CultureInfo.InvariantCulture);
        switch (exponent)
        {
            case 24:
                prefixedValue += "Y";
                break;
            case 21:
                prefixedValue += "Z";
                break;
            case 18:
                prefixedValue += "E";
                break;
            case 15:
                prefixedValue += "P";
                break;
            case 12:
                prefixedValue += "T";
                break;
            case 9:
                prefixedValue += "G";
                break;
            case 6:
                prefixedValue += "M";
                break;
            case 3:
                prefixedValue += "k";
                break;
            case 0:
                break;
            case -3:
                prefixedValue += "m";
                break;
            case -6:
                prefixedValue += "u";
                break;
            case -9:
                prefixedValue += "n";
                break;
            case -12:
                prefixedValue += "p";
                break;
            case -15:
                prefixedValue += "f";
                break;
            case -18:
                prefixedValue += "a";
                break;
            case -21:
                prefixedValue += "z";
                break;
            case -24:
                prefixedValue += "y";
                break;
            default:
                prefixedValue = "invalid";
                break;
        }

        return prefixedValue;
    }

    /// <summary>
    /// returns the double value for the si prefixed string
    /// </summary>
    /// <param name="prefixedValue">The prefixed value.</param>
    /// <returns>double value</returns>
    public static double FromSIPrefixedString(this string prefixedValue)
    {
        string scientificNotationValue = prefixedValue;

        if (scientificNotationValue.Contains("E+") == false && scientificNotationValue.Contains("E-") == false)
        {
            scientificNotationValue = scientificNotationValue
                .Replace("Y", "E+24")
                .Replace("Z", "E+21")
                .Replace("E", "E+18")
                .Replace("P", "E+15")
                .Replace("T", "E+12")
                .Replace("G", "E+09")
                .Replace("M", "E+06")
                .Replace("k", "E+03")
                .Replace("m", "E-03")
                .Replace("u", "E-06")
                .Replace("n", "E-09")
                .Replace("p", "E-12")
                .Replace("f", "E-15")
                .Replace("a", "E-18")
                .Replace("z", "E-21")
                .Replace("y", "E-24");
        }

        return Convert.ToDouble(scientificNotationValue, CultureInfo.InvariantCulture);
    }

Answer 5

это правильно в форме расширения.

    public static string ToSimpleK(this int val)
    {
        if (val > 1000000000)
            return ((decimal)val / 1000000000).ToString("0.00") + "b";
        else if (val > 1000000)
            return ((decimal)val / 1000000).ToString("0.00") + "m";
        else if (val > 1000)
            return ((decimal)val / 1000).ToString("0.00") + "k";
        else
            return val.ToString();
    }

Answer 6

Я думаю, что ваш вопрос является общим, в любом случае, я отправлю вам простой ответ для некоторого случая:

private string Cnv(int num)
{
    double DIV=1000f;

    double f = num;
    if (f<DIV) return num.ToString();
    f = num / DIV;
    if (f < DIV) return f.ToString("0.0k");
    f = num / DIV;
    if (f < DIV) return f.ToString("0.0m");
    return (f / DIV).ToString("0.0g");
}

Answer 7

Вы не сможете сделать это с помощью String.Format, но вы можете попробовать это:

int i = 2400;
string j = i/1000.0 + "k";
Console.WriteLine(j);