La mejor manera de mostrar decimal sin ceros finales

¿Hay un formateador de visualización que muestre decimales como estas representaciones de cadena en c # sin hacer ningún redondeo?

// decimal -> string 20 -> 20 20.00 -> 20 20.5 -> 20.5 20.5000 -> 20.5 20.125 -> 20.125 20.12500 -> 20.125 0.000 -> 0 

{0. #} se redondeará, y usar alguna función de tipo Trim no funcionará con una columna numérica encuadernada en una grilla.

¿Tiene una cantidad máxima de lugares decimales que alguna vez necesitará mostrar? (Sus ejemplos tienen un máximo de 5).

Si es así, creo que el formateo con “0. #####” haría lo que quieras.

  static void Main(string[] args) { var dList = new decimal[] { 20, 20.00m, 20.5m, 20.5000m, 20.125m, 20.12500m, 0.000m }; foreach (var d in dList) Console.WriteLine(d.ToString("0.#####")); } 

Acabo de aprender cómo usar correctamente el especificador de formato G Consulte la documentación de MSDN . Hay una nota un poco más abajo que indica que los ceros al final se conservarán para los tipos decimales cuando no se especifique la precisión. No sé por qué harían esto, pero especificar el número máximo de dígitos para nuestra precisión debería solucionar ese problema. Entonces, para formatear decimales, G29 es la mejor G29 .

 decimal test = 20.5000m; test.ToString("G"); // outputs 20.5000 like the documentation says it should test.ToString("G29"); // outputs 20.5 which is exactly what we want 

Este formato de cadena debería convertir su día: “0. #############################”. Tenga en cuenta que los decimales pueden tener como máximo 29 dígitos significativos.

Ejemplos:

 ? (1000000.00000000000050000000000m).ToString("0.#############################") -> 1000000.0000000000005 ? (1000000.00000000000050000000001m).ToString("0.#############################") -> 1000000.0000000000005 ? (1000000.0000000000005000000001m).ToString("0.#############################") -> 1000000.0000000000005000000001 ? (9223372036854775807.0000000001m).ToString("0.#############################") -> 9223372036854775807 ? (9223372036854775807.000000001m).ToString("0.#############################") -> 9223372036854775807.000000001 

Esta es otra variación de lo que vi arriba. En mi caso, necesito conservar todos los dígitos significativos a la derecha del punto decimal, es decir, soltar todos los ceros después del dígito más significativo. Solo pensé que sería bueno compartirlo. Sin embargo, no puedo garantizar la eficacia de esto, pero cuando trato de lograr la estética, ya está bastante condenado a las ineficiencias.

 public static string ToTrimmedString(this decimal target) { string strValue = target.ToString(); //Get the stock string //If there is a decimal point present if (strValue.Contains(".")) { //Remove all trailing zeros strValue = strValue.TrimEnd('0'); //If all we are left with is a decimal point if (strValue.EndsWith(".")) //then remove it strValue = strValue.TrimEnd('.'); } return strValue; } 

Eso es todo, solo quería dar mi granito de arena.

Método de extensión:

 public static class Extensions { public static string TrimDouble(this string temp) { var value = temp.IndexOf('.') == -1 ? temp : temp.TrimEnd('.', '0'); return value == string.Empty ? "0" : value; } } 

Código de ejemplo:

 double[] dvalues = {20, 20.00, 20.5, 20.5000, 20.125, 20.125000, 0.000}; foreach (var value in dvalues) Console.WriteLine(string.Format("{0} --> {1}", value, value.ToString().TrimDouble())); Console.WriteLine("=================="); string[] svalues = {"20", "20.00", "20.5", "20.5000", "20.125", "20.125000", "0.000"}; foreach (var value in svalues) Console.WriteLine(string.Format("{0} --> {1}", value, value.TrimDouble())); 

Salida:

 20 --> 20 20 --> 20 20,5 --> 20,5 20,5 --> 20,5 20,125 --> 20,125 20,125 --> 20,125 0 --> 0 ================== 20 --> 20 20.00 --> 2 20.5 --> 20.5 20.5000 --> 20.5 20.125 --> 20.125 20.125000 --> 20.125 0.000 --> 0 

Otra solución, basada en la respuesta de dyslexicanaboko , pero independiente de la cultura actual:

 public static string ToTrimmedString(this decimal num) { string str = num.ToString(); string decimalSeparator = CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator; if (str.Contains(decimalSeparator)) { str = str.TrimEnd('0'); if(str.EndsWith(decimalSeparator)) { str = str.RemoveFromEnd(1); } } return str; } public static string RemoveFromEnd(this string str, int characterCount) { return str.Remove(str.Length - characterCount, characterCount); } 

Es bastante fácil de hacer:

 Decimal YourValue; //just as example String YourString = YourValue.ToString().TrimEnd('0','.'); 

eso eliminará todos los ceros finales de tu decimal.

Lo único que debe hacer es agregar .ToString().TrimEnd('0','.'); a una variable decimal para convertir un decimal en una cadena sin ceros finales, como en el ejemplo anterior.

En algunas regiones, debe ser .ToString().TrimEnd('0',','); (donde nos usan una coma en lugar de un punto, pero también pueden agregar un punto y una coma como parámetros para estar seguros)

(también puede agregar ambos como parámetros)

No creo que sea posible de inmediato, pero un método simple como este debería hacerlo

 public static string TrimDecimal(decimal value) { string result = value.ToString(System.Globalization.CultureInfo.InvariantCulture); if (result.IndexOf('.') == -1) return result; return result.TrimEnd('0', '.'); } 
 decimal val = 0.000000000100m; string result = val == 0 ? "0" : val.ToString().TrimEnd('0').TrimEnd('.'); 

Terminé con el siguiente código:

  public static string DropTrailingZeros(string test) { if (test.Contains(CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator)) { test = test.TrimEnd('0'); } if (test.EndsWith(CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator)) { test = test.Substring(0, test.Length - CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator.Length); } return test; }