Eliminar ceros finales

Tengo algunos campos devueltos por una colección como

2.4200 2.0044 2.0000 

Quiero resultados como

 2.42 2.0044 2 

Intenté con String.Format , pero devuelve 2.0000 y al establecerlo en N0 redondea también los otros valores.

¿No es tan simple como esto, si la entrada ES una cadena? Puedes usar uno de estos:

 string.Format("{0:G29}", decimal.Parse("2.0044")) decimal.Parse("2.0044").ToString("G29") 2.0m.ToString("G29") 

Esto debería funcionar para todas las entradas.

Actualización Revise los formatos numéricos estándar que he tenido que establecer explícitamente el especificador de precisión en 29 como los documentos indican claramente:

Sin embargo, si el número es un decimal y se omite el especificador de precisión, siempre se utiliza la notación de punto fijo y se conservan los ceros al final

Actualización Konrad señaló en los comentarios:

Tenga cuidado con valores como 0.000001. El formato G29 los presentará de la manera más breve posible, por lo que cambiará a la notación exponencial. string.Format("{0:G29}", decimal.Parse("0.00000001",System.Globalization.CultureInfo.GetCultureInfo("en-US"))) dará como resultado “1E-08”.

Me encontré con el mismo problema, pero en un caso en el que no tengo el control de la salida en la cadena, que fue atendida por una biblioteca. Después de buscar detalles en la implementación del tipo Decimal (ver http://msdn.microsoft.com/en-us/library/system.decimal.getbits.aspx ), se me ocurrió un truco ingenioso (aquí como una extensión) método):

 public static decimal Normalize(this decimal value) { return value/1.000000000000000000000000000000000m; } 

La parte exponente del decimal se reduce a lo que se necesita. Llamar a ToString () en el decimal de salida escribirá el número sin ningún seguimiento de 0. Por ejemplo

 1.200m.Normalize().ToString(); 

En mi opinión es más seguro usar cadenas de formato numérico personalizado .

 decimal d = 0.00000000000010000000000m; string custom = d.ToString("0.#########################"); // gives: 0,0000000000001 string general = d.ToString("G29"); // gives: 1E-13 

Utilizo este código para evitar la notación científica “G29”:

 public static string DecimalToString(decimal dec) { string strdec = dec.ToString(CultureInfo.InvariantCulture); return strdec.Contains(".") ? strdec.TrimEnd('0').TrimEnd('.') : strdec; } 

Encontré una solución elegante de http://dobrzanski.net/2009/05/14/c-decimaltostring-and-how-to-get-rid-of-trailing-zeros/

Básicamente

decimal v = 2.4200M;

v.ToString (“#. ######”); // Regresará 2.42. El número de # es cuántos dígitos decimales admite.

Use el símbolo hash ( # ) para mostrar solo los 0 finales cuando sea necesario. Vea las pruebas a continuación.

 decimal num1 = 13.1534545765; decimal num2 = 49.100145; decimal num3 = 30.000235; num1.ToString("0.##"); //13.15% num2.ToString("0.##"); //49.1% num3.ToString("0.##"); //30% 

Esto hace exactamente lo que quieres:

Si su valor inicial es decimal :

 decimal source = 2.4200m; string output = ((double)source).ToString(); 

Si su valor inicial es string :

 string source = "2.4200"; string output = double.Parse(source).ToString(); 

Y debería costar un rendimiento mínimo.

Depende de lo que representa su número y cómo desea administrar los valores: ¿es una moneda, necesita redondeo o truncamiento, necesita este redondeo solo para mostrar?

Si para la visualización, considere formatear los números son x.ToString (“”)

http://msdn.microsoft.com/en-us/library/dwhawy9k.aspx y

http://msdn.microsoft.com/en-us/library/0c899ak8.aspx

Si solo se está redondeando, use Math.Round overload que requiere una sobrecarga de MidPointRounding

http://msdn.microsoft.com/en-us/library/ms131274.aspx )

Si obtiene su valor de una base de datos, considere la conversión en lugar de la conversión: double value = (decimal) myRecord [“columnName”];

Un enfoque de muy bajo nivel, pero creo que esta sería la forma más eficaz al usar solo cálculos de enteros rápidos (y sin métodos lentos de análisis de cadenas y de cultivo):

 public static decimal Normalize(this decimal d) { int[] bits = decimal.GetBits(d); int sign = bits[3] & (1 < < 31); int exp = (bits[3] >> 16) & 0x1f; uint a = (uint)bits[2]; // Top bits uint b = (uint)bits[1]; // Middle bits uint c = (uint)bits[0]; // Bottom bits while (exp > 0 && ((a % 5) * 6 + (b % 5) * 6 + c) % 10 == 0) { uint r; a = DivideBy10((uint)0, a, out r); b = DivideBy10(r, b, out r); c = DivideBy10(r, c, out r); exp--; } bits[0] = (int)c; bits[1] = (int)b; bits[2] = (int)a; bits[3] = (exp < < 16) | sign; return new decimal(bits); } private static uint DivideBy10(uint highBits, uint lowBits, out uint remainder) { ulong total = highBits; total <<= 32; total = total | (ulong)lowBits; remainder = (uint)(total % 10L); return (uint)(total / 10L); } 

Una respuesta muy simple es usar TrimEnd (). Aquí está el resultado,

 double value = 1.00; string output = value.ToString().TrimEnd('0'); 

La salida es 1 Si mi valor es 1.01, entonces mi salida será 1.01

El siguiente código podría usarse para no usar el tipo de cadena:

 int decimalResult = 789.500 while (decimalResult>0 && decimalResult % 10 == 0) { decimalResult = decimalResult / 10; } return decimalResult; 

Devuelve 789.5

Puedes simplemente establecer como:

 decimal decNumber = 23.45600000m; Console.WriteLine(decNumber.ToString("0.##")); 

Truncar los ceros finales es muy fácil, resolver con un molde dúplex:

  decimal mydecimal = decimal.Parse("1,45000000"); //(I) decimal truncate = (decimal)(double)mydecimal; //(II) 

(I) -> Parse el valor decimal de cualquier fuente de cadena.

(II) -> Primero: Convertir al doble para eliminar los ceros finales. Segundo: Otro elenco a decimal porque no existe conversión implícita de decimal a doble y viceversa

prueba este código:

 string value = "100"; value = value.Contains(".") ? value.TrimStart('0').TrimEnd('0').TrimEnd('.') : value.TrimStart('0'); 

prueba así

 string s = "2.4200"; s = s.TrimStart('0').TrimEnd('0', '.'); 

y luego convertir eso en flotar