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

mostrar solo 2 decimales en c#

Question

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

Answer 1

¿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);

Answer 2

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

Answer 3

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

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

Answer 4

Esto es trabajo para mí

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

Answer 5

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

Answer 6

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.

Answer 7

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

Answer 8

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

Answer 9

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.

Answer 10

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

Answer 11

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

Answer 12

decimal d = 0.241534545765m;  
decimal d2 = 0.241m;  
decimal d3 = 0.2m;  

d.ToString("0.##%");        //24.15%  
d2.ToString("0.##%");       //24.1%  
d3.ToString("0.##%");       //20%  

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