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

Question

¿Hay alguna manera de usar String.Format para convertir números en representaciones de números/caracteres.

Por ejemplo

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

Answer 1

estoy proporcionando una muestra código. Intente hacerlo en su 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 * 1e15).ToString() + "a"; 
       case -19: case -20: case -21: 
        return (d * 1e15).ToString() + "z"; 
       default: 
        return (d * 1e15).ToString() + "y"; 
      } 
     } 
     else 
     { 
      return "0"; 
     } 
    } 

Answer 2

No, no creo que hay una cadena de formato que lo hará por usted.

que pueden encontrarse con bibliotecas de terceros para hacerlo, y sé que están incorporados en las rutinas de Win32 para convertir un tamaño archivo a una representación de esa manera, sino que también puede utilizar 1024 en lugar de 1000 para el " base "de K/M/etc. This Stack Overflow answer 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 usted desea.

Answer 3

Escribí esto para usted.

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 4

Usted no será capaz de hacer esto utilizando String.Format pero se puede intentar esto:

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

Answer 5

También puede intentar lo siguiente:

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

continuación, reemplazar el exponente con la SI-prefijo deseado (por ejemplo e + 003 -> k, e + 006 -> M, e-009 -> n)

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

Answer 6

Creo que su pregunta es general, de todos modos yo te envío 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"); 
} 

Answer 7

esta es la correcta 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(); 
    }