c# - formato - La mejor manera de mostrar decimal sin ceros finales

string.format c# currency

Question

¿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.

Answer 1

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

Answer 2

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

Answer 3

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)

Answer 4

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.

Answer 5

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

Answer 6

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

Answer 7

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'', ''.'');
}

Answer 8

Otra solución, basada en dyslexicanaboko''s respuesta dyslexicanaboko''s , 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);
}

Answer 9

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

Answer 10

decimal val = 0.000000000100m;
string result = val == 0 ? "0" : val.ToString().TrimEnd(''0'').TrimEnd(''.'');