Pregunta String.Format para obtener "2.4k" de "2400"


¿Hay alguna manera de utilizar String.Format para convertir números a representaciones numéricas / de caracteres?

Por ejemplo

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

8
2018-04-11 05:59


origen


Respuestas:


Estoy proporcionando un código de muestra. Por favor trata de hacerlo en tu camino

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

5
2018-04-11 06:19



No, no creo que haya una cadena de formato que lo haga por ti.

Puede encontrar bibliotecas de terceros para hacerlo, y sé que hay rutinas Win32 integradas para convertir una tamaño del archivo a una representación como esa, pero que bien puede usar 1024 en lugar de 1000 para la "base" de K / M / etc. Esta respuesta de desbordamiento de pila muestra un código C #, pero estoy seguro de que también hay algo en la plataforma ... y como digo, está dirigido a tamaños de archivo, que pueden ser o no lo que quieres.


5
2018-04-11 06:08



Escribí esto para ti.

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

5
2018-04-11 06:11



También puedes probar lo siguiente:

Convierta su número en una cadena en formato científico: 2400 -> 2.4e + 003; 2,6,000,000 -> 2.6e + 006

Luego reemplace el exponente con el prefijo SI deseado (por ejemplo, e + 003 -> k, e + 006 -> M, e-009 -> n)

Creé la siguiente extensión para este propósito:

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

1
2018-04-11 06:14



No podrá hacer esto usando String.Format pero puede intentar esto:

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

0
2018-04-11 06:12



Creo que tu pregunta es general, de todos modos te publico una respuesta simple para algunos casos:

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

0
2018-04-11 06:16



este es el correcto en forma de extensión.

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

0
2018-02-26 11:45