C # Double – ToString () formateo con dos posiciones decimales pero sin redondeo

¿Cómo puedo formatear un Double en una String en C # para tener solo dos decimales?

Si utilizo String.Format("{0:0.00}%", myDoubleValue) el número se redondea y quiero un simple truncado sin redondeo. También quiero que la conversión a String sea ​​culturalmente sensible.

Yo uso lo siguiente:

 double x = Math.Truncate(myDoubleValue * 100) / 100; 

Por ejemplo:

Si el número es 50.947563 y utiliza lo siguiente, sucederá lo siguiente:

 - Math.Truncate(50.947563 * 100) / 100; - Math.Truncate(5094.7563) / 100; - 5094 / 100 - 50.94 

Y hay una respuesta truncada, ahora para formatear la cadena simplemente haz lo siguiente:

 string s = string.Format("{0:N2}%", x); // No fear of rounding and takes the default number format 

A continuación, redondea los números, pero solo muestra hasta 2 lugares decimales (eliminando los ceros al final), gracias a .## .

 decimal d0 = 24.154m; decimal d1 = 24.155m; decimal d2 = 24.1m; decimal d3 = 24.0m; d0.ToString("0.##"); //24.15 d1.ToString("0.##"); //24.16 (rounded up) d2.ToString("0.##"); //24.1 d3.ToString("0.##"); //24 

http://dobrzanski.net/2009/05/14/c-decimaltostring-and-how-to-get-rid-of-trailing-zeros/

Le sugiero que trunque primero, y luego formatee:

 double a = 123.4567; double aTruncated = Math.Truncate(a * 100) / 100; CultureInfo ci = new CultureInfo("de-DE"); string s = string.Format(ci, "{0:0.00}%", aTruncated); 

Utilice la constante 100 para 2 dígitos truncado; utilice un 1 seguido de tantos ceros como dígitos después del punto decimal que desee. Use el nombre de la cultura que necesita para ajustar el resultado del formateo.

El método más simple, use cadenas de formato numérico:

 double total = "43.257" MessageBox.Show(total.ToString("F")); 

yo uso price.ToString("0.00") para obtener los primeros 0

Esto es trabajo para mí

 string prouctPrice = Convert.ToDecimal(String.Format("{0:0.00}", Convert.ToDecimal(yourString))).ToString(); 

La función c #, como lo expresó Kyle Rozendo:

 string DecimalPlaceNoRounding(double d, int decimalPlaces = 2) { d = d * Math.Pow(10, decimalPlaces); d = Math.Truncate(d); d = d / Math.Pow(10, decimalPlaces); return string.Format("{0:N" + Math.Abs(decimalPlaces) + "}", d); } 

¿Qué tal si agregamos un decimal adicional que debe redondearse y luego descartarse?

 var d = 0.241534545765; var result1 = d.ToString("0.###%"); var result2 = result1.Remove(result1.Length - 1); 

Sé que este es un hilo viejo, pero acabo de tener que hacer esto. Mientras que los otros enfoques aquí funcionan, quería una manera fácil de poder afectar a un montón de llamadas a string.format . Entonces, agregar Math.Truncate a todas las llamadas no era realmente una buena opción. Además, como parte del formato se almacena en una base de datos, lo hizo aún peor.

Por lo tanto, hice un proveedor de formato personalizado que me permitiría agregar truncamiento a la cadena de formato, por ejemplo:

 string.format(new FormatProvider(), "{0:T}", 1.1299); // 1.12 string.format(new FormatProvider(), "{0:T(3)", 1.12399); // 1.123 string.format(new FormatProvider(), "{0:T(1)0,000.0", 1000.9999); // 1,000.9 

La implementación es bastante simple y es fácilmente extensible a otros requisitos.

 public class FormatProvider : IFormatProvider, ICustomFormatter { public object GetFormat(Type formatType) { if (formatType == typeof (ICustomFormatter)) { return this; } return null; } public string Format(string format, object arg, IFormatProvider formatProvider) { if (arg == null || arg.GetType() != typeof (double)) { try { return HandleOtherFormats(format, arg); } catch (FormatException e) { throw new FormatException(string.Format("The format of '{0}' is invalid.", format)); } } if (format.StartsWith("T")) { int dp = 2; int idx = 1; if (format.Length > 1) { if (format[1] == '(') { int closeIdx = format.IndexOf(')'); if (closeIdx > 0) { if (int.TryParse(format.Substring(2, closeIdx - 2), out dp)) { idx = closeIdx + 1; } } else { throw new FormatException(string.Format("The format of '{0}' is invalid.", format)); } } } double mult = Math.Pow(10, dp); arg = Math.Truncate((double)arg * mult) / mult; format = format.Substring(idx); } try { return HandleOtherFormats(format, arg); } catch (FormatException e) { throw new FormatException(string.Format("The format of '{0}' is invalid.", format)); } } private string HandleOtherFormats(string format, object arg) { if (arg is IFormattable) { return ((IFormattable) arg).ToString(format, CultureInfo.CurrentCulture); } return arg != null ? arg.ToString() : String.Empty; } } 

A continuación se puede utilizar para mostrar solo que utiliza la propiedad de String ..

 double value = 123.456789; String.Format("{0:0.00}", value); 

Para lo que vale, para mostrar moneda, puede usar "C" :

 double cost = 1.99; m_CostText.text = cost.ToString("C"); /*C: format as currentcy */ 

Salida: $1.99

También podría escribir su propio IFormatProvider , aunque supongo que finalmente tendría que pensar en una forma de hacer el truncamiento real.

.NET Framework también es compatible con el formato personalizado. Esto generalmente implica la creación de una clase de formato que implementa tanto IFormatProvider como ICustomFormatter . (msdn)

Al menos sería fácilmente reutilizable.

Hay un artículo sobre cómo implementar su propio IFormatProvider / ICustomFormatter aquí en CodeProject . En este caso, “extender” un formato numérico existente podría ser la mejor opción. No parece muy difícil.

Tuve ese problema con xamarin y lo resolví con:

 porcent.ToString("0.##"+"%")