C # Double - Formatage ToString () avec deux décimales mais pas d'arrondi

Comment formater un Doubleen un Stringen C # pour n'avoir que deux décimales?

Si j'utilise String.Format("{0:0.00}%", myDoubleValue)le nombre est alors arrondi et je veux une simple troncature sans aucun arrondi. Je souhaite également que la conversion Stringsoit sensible à la culture.

J'utilise ce qui suit:

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

Par exemple:

Si le numéro est 50,947563 et que vous utilisez ce qui suit, les événements suivants se produiront:

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

Et votre réponse est tronquée, maintenant pour formater la chaîne, procédez simplement comme suit:

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

Ce qui suit arrondit les nombres, mais n'affiche que 2 décimales maximum (en supprimant les zéros de fin), grâce à .##.

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/

Je vous suggère de tronquer d'abord, puis de formater:

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

Utilisez la constante 100 pour tronquer 2 chiffres; utilisez un 1 suivi d'autant de zéros que de chiffres après la virgule décimale que vous souhaitez. Utilisez le nom de culture dont vous avez besoin pour ajuster le résultat de la mise en forme.

Méthode la plus simple, utilisez des chaînes de format numérique:

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

j'utilise price.ToString("0.00") pour obtenir les 0 premiers

La fonction c #, telle qu'exprimée par 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);
}

Que diriez-vous d'ajouter une décimale supplémentaire à arrondir puis à supprimer:

var d = 0.241534545765;
var result1 = d.ToString("0.###%");

var result2 = result1.Remove(result1.Length - 1);

Cela fonctionne pour moi

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

Je sais que c'est un vieux fil mais j'ai juste dû le faire. Bien que les autres approches fonctionnent ici, je voulais un moyen simple de pouvoir affecter de nombreux appels à string.format. Donc, ajouter le Math.Truncateà tous les appels n'était pas vraiment une bonne option. De plus, comme une partie du formatage est stockée dans une base de données, la situation est encore pire.

Ainsi, j'ai créé un fournisseur de format personnalisé qui me permettrait d'ajouter une troncature à la chaîne de formatage, par exemple:

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 mise en œuvre est assez simple et est facilement extensible à d'autres exigences.

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

J'ai eu ce problème avec Xamarin Forms et je l'ai résolu avec ceci:

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

Pour ce qui vaut, pour afficher la devise, vous pouvez utiliser "C":

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

Production: $1.99

Vous pouvez également écrire votre propre IFormatProvider , même si je suppose que vous devrez éventuellement penser à un moyen de faire la troncature réelle.

Le .NET Framework prend également en charge la mise en forme personnalisée. Cela implique généralement la création d'une classe de mise en forme qui implémente à la fois IFormatProvider et ICustomFormatter . (msdn)

Au moins, il serait facilement réutilisable.

Il existe un article sur la façon d'implémenter votre propre IFormatProvider / ICustomFormatter ici sur CodeProject . Dans ce cas, "étendre" un format numérique existant peut être le meilleur choix. Cela n'a pas l'air trop dur.

Ce qui suit peut être utilisé pour l'affichage uniquement qui utilise la propriété de String.

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

Solution:

var d = 0.123345678; 
var stringD = d.ToString(); 
int indexOfP = stringD.IndexOf("."); 
var result = stringD.Remove((indexOfP+1)+2);

(indexOfP + 1) +2 (ce nombre dépend du nombre que vous souhaitez conserver. Je lui donne deux parce que le propriétaire de la question le souhaite.)

Notez également les informations sur la culture de votre système. Voici ma solution sans arrondir.

Dans cet exemple, il vous suffit de définir la variable MyValue comme double. En conséquence, vous obtenez votre valeur formatée dans la variable de chaîne NewValue .

Remarque - Définissez également l'instruction en utilisant C #:

using System.Globalization;  

string MyFormat = "0";
if (MyValue.ToString (CultureInfo.InvariantCulture).Contains (CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator))
   {
      MyFormat += ".00";
   }

string NewValue = MyValue.ToString(MyFormat);