Der beste Weg, um Dezimalstellen ohne nachgestellte Nullen anzuzeigen

Gibt es einen Anzeigeformatierer, der Dezimalstellen als diese Zeichenfolgendarstellungen in c # ausgibt, ohne eine Rundung vorzunehmen?

// decimal -> string

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. #} wird gerundet, und die Verwendung einer Funktion zum Zuschneiden funktioniert nicht mit einer gebundenen numerischen Spalte in einem Raster.

Haben Sie eine maximale Anzahl von Dezimalstellen, die Sie jemals anzeigen müssen? (Ihre Beispiele haben maximal 5).

Wenn ja, würde ich denken, dass die Formatierung mit "0. #####" tun würde, was Sie wollen.

    static void Main(string[] 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.ToString("0.#####"));
    }

Ich habe gerade gelernt, wie man den GFormatbezeichner richtig verwendet . Siehe die MSDN-Dokumentation . Etwas weiter unten befindet sich ein Hinweis, der besagt, dass nachgestellte Nullen für Dezimaltypen beibehalten werden, wenn keine Genauigkeit angegeben ist. Warum sie dies tun würden, weiß ich nicht, aber die Angabe der maximalen Anzahl von Stellen für unsere Genauigkeit sollte dieses Problem beheben. Für die Formatierung von Dezimalstellen G29ist dies die beste Wahl.

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

Dieses Zeichenfolgenformat sollte Ihren Tag bestimmen: "0. ###############################". Beachten Sie jedoch, dass Dezimalstellen höchstens 29 signifikante Stellen haben können.

Beispiele:

? (1000000.00000000000050000000000m).ToString("0.#############################")
-> 1000000.0000000000005

? (1000000.00000000000050000000001m).ToString("0.#############################")
-> 1000000.0000000000005

? (1000000.0000000000005000000001m).ToString("0.#############################")
-> 1000000.0000000000005000000001

? (9223372036854775807.0000000001m).ToString("0.#############################")
-> 9223372036854775807

? (9223372036854775807.000000001m).ToString("0.#############################")
-> 9223372036854775807.000000001

Dies ist eine weitere Variation dessen, was ich oben gesehen habe. In meinem Fall muss ich alle signifikanten Ziffern rechts vom Dezimalpunkt beibehalten, dh alle Nullen nach der höchstwertigen Ziffer löschen. Ich dachte nur, es wäre schön zu teilen. Ich kann zwar nicht für die Effizienz bürgen, aber wenn Sie versuchen, Ästhetik zu erreichen, sind Sie bereits zu Ineffizienzen verdammt.

public static string ToTrimmedString(this decimal target)
{
    string strValue = target.ToString(); //Get the stock string

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

Das ist alles, ich wollte nur meine zwei Cent einwerfen.

Eine andere Lösung, die auf der Antwort von Legastheniker basiert , jedoch unabhängig von der aktuellen Kultur ist:

public static string ToTrimmedString(this decimal num)
{
    string str = num.ToString();
    string 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 string RemoveFromEnd(this string str, int characterCount)
{
    return str.Remove(str.Length - characterCount, characterCount);
}

Verlängerungsmethode:

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

Beispielcode:

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

Console.WriteLine("==================");

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

Ausgabe:

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

Ich denke nicht, dass es sofort möglich ist, aber eine einfache Methode wie diese sollte es tun

public static string TrimDecimal(decimal value)
{
    string result = value.ToString(System.Globalization.CultureInfo.InvariantCulture);
    if (result.IndexOf('.') == -1)
        return result;

    return result.TrimEnd('0', '.');
}

Es ist ganz einfach, sofort loszulegen:

Decimal YourValue; //just as example   
String YourString = YourValue.ToString().TrimEnd('0','.');

Dadurch werden alle nachgestellten Nullen aus Ihrer Dezimalzahl entfernt.

Das einzige, was Sie tun müssen, ist das Hinzufügen .ToString().TrimEnd('0','.');zu einer Dezimalvariablen, um a Decimalin eine Stringohne nachgestellte Nullen umzuwandeln , wie im obigen Beispiel.

In einigen Regionen sollte es ein sein .ToString().TrimEnd('0',',');(wo sie ein Komma anstelle eines Punktes verwenden, aber Sie können auch einen Punkt und ein Komma als Parameter hinzufügen, um sicherzugehen).

(Sie können auch beide als Parameter hinzufügen)

decimal val = 0.000000000100m;
string result = val == 0 ? "0" : val.ToString().TrimEnd('0').TrimEnd('.');

Am Ende hatte ich folgenden Code:

    public static string DropTrailingZeros(string test)
    {
        if (test.Contains(CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator))
        {
            test = test.TrimEnd('0');
        }

        if (test.EndsWith(CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator))
        {
            test = test.Substring(0,
                test.Length - CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator.Length);
        }

        return test;
    }

Ich bin mit dieser Variante gelandet:

public static string Decimal2StringCompact(decimal value, int maxDigits)
    {
        if (maxDigits < 0) maxDigits = 0;
        else if (maxDigits > 28) maxDigits = 28;
        return Math.Round(value, maxDigits, MidpointRounding.ToEven).ToString("0.############################", CultureInfo.InvariantCulture);
    }

Vorteile:

Sie können die maximale Anzahl von signifikanten Stellen nach dem Punkt angeben, der zur Laufzeit angezeigt werden soll.

Sie können explizit eine runde Methode angeben.

Sie können eine Kultur explizit steuern.

Sie können eine Erweiterungsmethode erstellen

public static class ExtensionMethod {
  public static decimal simplify_decimal(this decimal value) => decimal.Parse($"{this:0.############}");
}

Ich habe die folgenden Erweiterungsmethoden für mich erstellt, um sie an eines meiner Projekte anzupassen, aber vielleicht sind sie für andere von Vorteil.

using System.Numerics;
using System.Text.RegularExpressions;
internal static class ExtensionMethod
{
    internal static string TrimDecimal(this BigInteger obj) => obj.ToString().TrimDecimal();
    internal static string TrimDecimal(this decimal obj) => new BigInteger(obj).ToString().TrimDecimal();
    internal static string TrimDecimal(this double obj) => new BigInteger(obj).ToString().TrimDecimal();
    internal static string TrimDecimal(this float obj) => new BigInteger(obj).ToString().TrimDecimal();
    internal static string TrimDecimal(this string obj)
    {
        if (string.IsNullOrWhiteSpace(obj) || !Regex.IsMatch(obj, @"^(\d+([.]\d*)?|[.]\d*)$")) return string.Empty;
        Regex regex = new Regex("^[0]*(?<pre>([0-9]+)?)(?<post>([.][0-9]*)?)$");
        MatchEvaluator matchEvaluator = m => string.Concat(m.Groups["pre"].Length > 0 ? m.Groups["pre"].Value : "0", m.Groups["post"].Value.TrimEnd(new[] { '.', '0' }));
        return regex.Replace(obj, matchEvaluator);
    }
}

Es wird jedoch ein Verweis auf erforderlich sein System.Numerics.