Supprimer les zéros de fin

J'ai des champs renvoyés par une collection comme

2.4200
2.0044
2.0000

Je veux des résultats comme

2.42
2.0044
2

J'ai essayé avec String.Format, mais il retourne 2.0000et le définit pour N0arrondir également les autres valeurs.

N'est-ce pas aussi simple que cela, si l'entrée EST une chaîne? Vous pouvez utiliser l'un de ceux-ci:

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

decimal.Parse("2.0044").ToString("G29")

2.0m.ToString("G29")

Cela devrait fonctionner pour toutes les entrées.

Mise à jour Vérifiez les formats numériques standard que j'ai dû définir explicitement le spécificateur de précision sur 29, comme l'indique clairement la documentation:

Cependant, si le nombre est un décimal et que le spécificateur de précision est omis, la notation à virgule fixe est toujours utilisée et les zéros de fin sont conservés

Update Konrad a souligné dans les commentaires:

Méfiez-vous des valeurs comme 0,000001. Le format G29 les présentera de la manière la plus courte possible afin de passer à la notation exponentielle. string.Format("{0:G29}", decimal.Parse("0.00000001",System.Globalization.CultureInfo.GetCultureInfo("en-US")))donnera "1E-08" comme résultat.

J'ai rencontré le même problème mais dans un cas où je n'ai pas le contrôle de la sortie en chaîne, qui a été prise en charge par une bibliothèque. Après avoir examiné les détails de l'implémentation du type Decimal (voir http://msdn.microsoft.com/en-us/library/system.decimal.getbits.aspx ), j'ai trouvé une astuce intéressante (ici en extension méthode):

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

La partie exposant de la décimale est réduite à ce qui est nécessaire. L'appel de ToString () sur la décimale de sortie écrira le nombre sans aucun 0 à la fin. Par exemple

1.200m.Normalize().ToString();

À mon avis, il est plus sûr d'utiliser des chaînes de format numérique personnalisées .

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

J'utilise ce code pour éviter la notation scientifique "G29":

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

EDIT: en utilisant le système CultureInfo.NumberFormat.NumberDecimalSeparator:

public static string DecimalToString(this decimal dec)
{
    string sep = CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator;
    string strdec = dec.ToString(CultureInfo.CurrentCulture);
    return strdec.Contains(sep) ? strdec.TrimEnd('0').TrimEnd(sep.ToCharArray()) : strdec;
}

Utilisez le #symbole dièse ( ) pour n'afficher que les 0 à la fin lorsque cela est nécessaire. Voir les tests ci-dessous.

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%

J'ai trouvé une solution élégante sur http://dobrzanski.net/2009/05/14/c-decimaltostring-and-how-to-get-rid-of-trailing-zeros/

Fondamentalement

decimal v=2.4200M;

v.ToString("#.######"); // Will return 2.42. The number of # is how many decimal digits you support.

Une approche de très bas niveau, mais je pense que ce serait le moyen le plus performant en utilisant uniquement des calculs d'entiers rapides (et pas de méthodes d'analyse lente des chaînes et sensibles à la culture):

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

Cela fonctionnera:

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

Ou si votre valeur initiale est string:

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

Faites attention à ce commentaire .

C'est simple.

decimal decNumber = Convert.ToDecimal(value);
        return decNumber.ToString("0.####");

Testé.

À votre santé :)

Cela dépend de ce que représente votre nombre et de la façon dont vous souhaitez gérer les valeurs: est-ce une devise, avez-vous besoin d'arrondi ou de troncature, avez-vous besoin de cet arrondi uniquement pour l'affichage?

Si pour l'affichage, pensez au formatage, les nombres sont x.ToString ("")

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

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

S'il s'agit simplement d'arrondi, utilisez une surcharge Math.Round qui nécessite une surcharge MidPointRounding

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

Si vous obtenez votre valeur à partir d'une base de données, envisagez la conversion au lieu de la conversion: double value = (decimal) myRecord ["columnName"];

Vous pouvez simplement définir comme:

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

Si vous souhaitez conserver le nombre décimal, essayez l'exemple suivant:

number = Math.Floor(number * 100000000) / 100000000;

Essayer de faire une solution plus conviviale de DecimalToString ( https://stackoverflow.com/a/34486763/3852139 ):

private static decimal Trim(this decimal value)
{
    var s = value.ToString(CultureInfo.InvariantCulture);
    return s.Contains(CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator)
        ? Decimal.Parse(s.TrimEnd('0'), CultureInfo.InvariantCulture)
        : value;
}

private static decimal? Trim(this decimal? value)
{
    return value.HasValue ? (decimal?) value.Value.Trim() : null;
}

private static void Main(string[] args)
{
    Console.WriteLine("=>{0}", 1.0000m.Trim());
    Console.WriteLine("=>{0}", 1.000000023000m.Trim());
    Console.WriteLine("=>{0}", ((decimal?) 1.000000023000m).Trim());
    Console.WriteLine("=>{0}", ((decimal?) null).Trim());
}

Production:

=>1
=>1.000000023
=>1.000000023
=>

La réponse très simple consiste à utiliser TrimEnd (). Voici le résultat,

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

La sortie est 1 Si ma valeur est 1,01, ma sortie sera 1,01

Le code suivant peut être utilisé pour ne pas utiliser le type chaîne:

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

Renvoie 789,5

Tronquer les zéros de fin est très simple, résolvez-les avec une conversion duplex:

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

(I) -> Analyser la valeur décimale de n'importe quelle source de chaîne.

(II) -> First: Cast pour doubler cette suppression des zéros de fin. Deuxièmement: Autre conversion en décimal car il n'existe pas de conversion implicite de décimal en double et vice versa)

essayez ce code:

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

essayez comme ça

string s = "2.4200";

s = s.TrimStart('0').TrimEnd('0', '.');

puis convertissez cela en float