Meilleur moyen d’afficher les décimales sans les zéros à la fin

Existe-t-il un formateur d’affichage qui affichera des décimales comme ces représentations de chaînes dans c # sans arrondir?

// decimal -> ssortingng 20 -> 20 20.00 -> 20 20.5 -> 20.5 20.5000 -> 20.5 20.125 -> 20.125 20.12500 -> 20.125 0.000 -> 0 

{0. #} arrondira et l’utilisation d’une fonction de type Trim ne fonctionnera pas avec une colonne numérique liée dans une grid.

Avez-vous un nombre maximum de décimales à afficher? (Vos exemples ont un maximum de 5).

Si oui, je pense que le formatage avec “0. #####” ferait ce que vous voulez.

  static void Main(ssortingng[] args) { var dList = new decimal[] { 20, 20.00m, 20.5m, 20.5000m, 20.125m, 20.12500m, 0.000m }; foreach (var d in dList) Console.WriteLine(d.ToSsortingng("0.#####")); } 

Je viens d’apprendre comment utiliser correctement le spécificateur de format G Voir la documentation MSDN . Une note un peu plus bas indique que les zéros à la fin seront conservés pour les types décimaux lorsque aucune précision n’est spécifiée. Pourquoi ils le feraient, je ne sais pas, mais spécifier le nombre maximum de chiffres pour notre précision devrait résoudre ce problème. Donc, pour formater des décimales, G29 est le meilleur pari.

 decimal test = 20.5000m; test.ToSsortingng("G"); // outputs 20.5000 like the documentation says it should test.ToSsortingng("G29"); // outputs 20.5 which is exactly what we want 

Ce format de chaîne doit faire votre journée: “0. #############################”. Gardez à l’esprit que les décimales peuvent avoir au plus 29 chiffres significatifs.

Exemples:

 ? (1000000.00000000000050000000000m).ToSsortingng("0.#############################") -> 1000000.0000000000005 ? (1000000.00000000000050000000001m).ToSsortingng("0.#############################") -> 1000000.0000000000005 ? (1000000.0000000000005000000001m).ToSsortingng("0.#############################") -> 1000000.0000000000005000000001 ? (9223372036854775807.0000000001m).ToSsortingng("0.#############################") -> 9223372036854775807 ? (9223372036854775807.000000001m).ToSsortingng("0.#############################") -> 9223372036854775807.000000001 

Ceci est encore une autre variation de ce que j’ai vu ci-dessus. Dans mon cas, je dois conserver tous les chiffres significatifs à droite du séparateur décimal, ce qui signifie que tous les zéros sont supprimés après le chiffre le plus significatif. Juste pensé que ce serait bien de partager. Je ne peux cependant pas garantir l’efficacité de ce procédé, mais lorsque vous essayez d’atteindre l’esthétique, vous êtes déjà à deux doigts d’être inefficace.

 public static ssortingng ToTrimmedSsortingng(this decimal target) { ssortingng strValue = target.ToSsortingng(); //Get the stock ssortingng //If there is a decimal point present if (strValue.Contains(".")) { //Remove all trailing zeros strValue = strValue.TrimEnd('0'); //If all we are left with is a decimal point if (strValue.EndsWith(".")) //then remove it strValue = strValue.TrimEnd('.'); } return strValue; } 

C’est tout, je voulais juste jeter mes deux cents.

Méthode d’extension:

 public static class Extensions { public static ssortingng TrimDouble(this ssortingng temp) { var value = temp.IndexOf('.') == -1 ? temp : temp.TrimEnd('.', '0'); return value == ssortingng.Empty ? "0" : value; } } 

Exemple de code:

 double[] dvalues = {20, 20.00, 20.5, 20.5000, 20.125, 20.125000, 0.000}; foreach (var value in dvalues) Console.WriteLine(ssortingng.Format("{0} --> {1}", value, value.ToSsortingng().TrimDouble())); Console.WriteLine("=================="); ssortingng[] svalues = {"20", "20.00", "20.5", "20.5000", "20.125", "20.125000", "0.000"}; foreach (var value in svalues) Console.WriteLine(ssortingng.Format("{0} --> {1}", value, value.TrimDouble())); 

Sortie:

 20 --> 20 20 --> 20 20,5 --> 20,5 20,5 --> 20,5 20,125 --> 20,125 20,125 --> 20,125 0 --> 0 ================== 20 --> 20 20.00 --> 2 20.5 --> 20.5 20.5000 --> 20.5 20.125 --> 20.125 20.125000 --> 20.125 0.000 --> 0 

Une autre solution, basée sur la réponse de dyslexicanaboko, mais indépendante de la culture actuelle:

 public static ssortingng ToTrimmedSsortingng(this decimal num) { ssortingng str = num.ToSsortingng(); ssortingng decimalSeparator = CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator; if (str.Contains(decimalSeparator)) { str = str.TrimEnd('0'); if(str.EndsWith(decimalSeparator)) { str = str.RemoveFromEnd(1); } } return str; } public static ssortingng RemoveFromEnd(this ssortingng str, int characterCount) { return str.Remove(str.Length - characterCount, characterCount); } 

Il est assez facile de sortir de la boîte:

 Decimal YourValue; //just as example Ssortingng YourSsortingng = YourValue.ToSsortingng().TrimEnd('0','.'); 

cela supprimera tous les zéros de fin de votre décimal.

La seule chose à faire est d’append .ToSsortingng().TrimEnd('0','.'); à une variable décimale pour convertir un décimal en chaîne sans les zéros de fin, comme dans l’exemple ci-dessus.

Dans certaines régions, cela devrait être un .ToSsortingng().TrimEnd('0',','); (où ils sont une virgule au lieu d’un point, mais vous pouvez également append un point et une virgule comme parameters pour être sûr)

(vous pouvez également append les deux comme parameters)

Je ne pense pas que ce soit possible, mais une méthode simple comme celle-ci devrait le faire

 public static ssortingng TrimDecimal(decimal value) { ssortingng result = value.ToSsortingng(System.Globalization.CultureInfo.InvariantCulture); if (result.IndexOf('.') == -1) return result; return result.TrimEnd('0', '.'); } 
 decimal val = 0.000000000100m; ssortingng result = val == 0 ? "0" : val.ToSsortingng().TrimEnd('0').TrimEnd('.'); 

J’ai fini avec le code suivant:

  public static ssortingng DropTrailingZeros(ssortingng test) { if (test.Contains(CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator)) { test = test.TrimEnd('0'); } if (test.EndsWith(CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator)) { test = test.Subssortingng(0, test.Length - CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator.Length); } return test; }