Entfernen Sie nachgestellte Nullen

Ich habe einige Felder von einer Sammlung als zurückgegeben

2.4200
2.0044
2.0000

Ich möchte Ergebnisse wie

2.42
2.0044
2

Ich habe es mit versucht String.Format, aber es kehrt zurück 2.0000und setzt es so, dass auch N0die anderen Werte gerundet werden.

Ist es nicht so einfach, wenn die Eingabe eine Zeichenfolge ist? Sie können eine davon verwenden:

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

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

2.0m.ToString("G29")

Dies sollte für alle Eingaben funktionieren.

Update Schauen Sie sich die numerischen Standardformate an. Ich musste den Präzisionsspezifizierer explizit auf 29 setzen, da in den Dokumenten eindeutig angegeben ist:

Wenn die Zahl jedoch eine Dezimalzahl ist und der Präzisionsspezifizierer weggelassen wird, wird immer die Festkommanotation verwendet und nachfolgende Nullen bleiben erhalten

Update Konrad wies in den Kommentaren darauf hin:

Achten Sie auf Werte wie 0,000001. Das G29-Format präsentiert sie auf kürzestem Weg, sodass zur Exponentialschreibweise gewechselt wird. string.Format("{0:G29}", decimal.Parse("0.00000001",System.Globalization.CultureInfo.GetCultureInfo("en-US")))gibt als Ergebnis "1E-08".

Ich bin auf das gleiche Problem gestoßen, aber in einem Fall, in dem ich keine Kontrolle über die Ausgabe in einen String habe, der von einer Bibliothek erledigt wurde. Nachdem ich mich mit Details bei der Implementierung des Dezimaltyps befasst hatte (siehe http://msdn.microsoft.com/en-us/library/system.decimal.getbits.aspx ), kam ich auf einen tollen Trick (hier als Erweiterung) Methode):

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

Der Exponententeil der Dezimalstelle wird auf das reduziert, was benötigt wird. Wenn Sie ToString () auf der Ausgangsdezimalstelle aufrufen, wird die Zahl ohne nachgestellte 0 geschrieben

1.200m.Normalize().ToString();

Meiner Meinung nach ist es sicherer, benutzerdefinierte Zeichenfolgen im numerischen Format zu verwenden .

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

Ich benutze diesen Code, um die wissenschaftliche Notation "G29" zu vermeiden:

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

BEARBEITEN: Verwenden des Systems 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;
}

Verwenden Sie das #Symbol hash ( ), um nachfolgende Nullen nur bei Bedarf anzuzeigen. Siehe die Tests unten.

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%

Ich fand eine elegante Lösung von http://dobrzanski.net/2009/05/14/c-decimaltostring-and-how-to-get-rid-of-trailing-zeros/

Grundsätzlich

decimal v=2.4200M;

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

Ein Ansatz auf sehr niedriger Ebene, aber ich glaube, dies wäre der performanteste Weg, wenn nur schnelle Ganzzahlberechnungen (und keine langsamen String-Parsing- und kultursensitiven Methoden) verwendet werden:

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

Das wird funktionieren:

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

Oder wenn Ihr Anfangswert ist string:

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

Achten Sie auf diesen Kommentar .

Das ist einfach.

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

Geprüft.

Prost :)

Hängt davon ab, was Ihre Nummer darstellt und wie Sie die Werte verwalten möchten: Ist es eine Währung, benötigen Sie eine Rundung oder Kürzung, benötigen Sie diese Rundung nur für die Anzeige?

Wenn für die Anzeige eine Formatierung in Betracht gezogen wird, lauten die Zahlen x.ToString ("")

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

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

Wenn es sich nur um eine Rundung handelt, verwenden Sie die Math.Round-Überladung, die eine MidPointRounding-Überladung erfordert

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

Wenn Sie Ihren Wert aus einer Datenbank erhalten, ziehen Sie das Casting anstelle der Konvertierung in Betracht: double value = (decimal) myRecord ["columnName"];

Sie können einfach einstellen als:

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

Wenn Sie die Dezimalzahl beibehalten möchten, versuchen Sie folgendes Beispiel:

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

Versuch, eine benutzerfreundlichere Lösung für DecimalToString zu finden ( 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());
}

Ausgabe:

=>1
=>1.000000023
=>1.000000023
=>

Eine sehr einfache Antwort ist die Verwendung von TrimEnd (). Hier ist das Ergebnis,

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

Ausgabe ist 1 Wenn mein Wert 1,01 ist, ist meine Ausgabe 1,01

Der folgende Code kann verwendet werden, um den Zeichenfolgentyp nicht zu verwenden:

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

Rückgabe 789.5

Das Abschneiden von nachgestellten Nullen ist sehr einfach und kann mit einer Duplex-Besetzung gelöst werden:

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

(I) -> Analysiert den Dezimalwert aus einer beliebigen Zeichenfolgenquelle.

(II) -> Zuerst: Um dies zu verdoppeln, entfernen Sie die nachgestellten Nullen. Zweitens: Andere Umwandlung in Dezimalzahl, da keine implizite Konvertierung von Dezimalzahl in Doppel- und umgekehrt existiert.

Versuchen Sie diesen Code:

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

versuche es so

string s = "2.4200";

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

und konvertiere das dann in float