Rimuovi gli zeri finali

Ho alcuni campi restituiti da una raccolta come

2.4200
2.0044
2.0000

Voglio risultati come

2.42
2.0044
2

Ho provato con String.Format, ma ritorna 2.0000e lo imposta per N0arrotondare anche gli altri valori.

Non è così semplice, se l'ingresso È una stringa? Puoi usare uno di questi:

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

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

2.0m.ToString("G29")

Questo dovrebbe funzionare per tutti gli input.

Aggiornamento Dai un'occhiata ai formati numerici standard che ho dovuto impostare esplicitamente lo specificatore di precisione su 29, come chiaramente indicato dai documenti:

Tuttavia, se il numero è un decimale e l'identificatore di precisione viene omesso, viene sempre utilizzata la notazione a virgola fissa e gli zeri finali vengono conservati

Aggiornamento Konrad sottolineato nei commenti:

Fai attenzione a valori come 0,000001. Il formato G29 li presenterà nel modo più breve possibile, quindi passerà alla notazione esponenziale. string.Format("{0:G29}", decimal.Parse("0.00000001",System.Globalization.CultureInfo.GetCultureInfo("en-US")))darà "1E-08" come risultato.

Ho riscontrato lo stesso problema, ma in un caso in cui non ho il controllo dell'output su stringa, che è stato curato da una libreria. Dopo aver esaminato i dettagli nell'implementazione del tipo Decimale (vedi http://msdn.microsoft.com/en-us/library/system.decimal.getbits.aspx ), ho trovato un trucco accurato (qui come estensione metodo):

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

La parte esponente del decimale è ridotta a ciò che è necessario. Chiamando ToString () sul decimale di output si scriverà il numero senza alcun 0. 0 ad es

1.200m.Normalize().ToString();

Secondo me è più sicuro usare stringhe di formato numerico personalizzate .

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

Uso questo codice per evitare la notazione scientifica "G29":

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

EDIT: utilizzando il sistema 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;
}

Utilizzare il #simbolo hash ( ) per visualizzare gli 0 finali solo quando necessario. Vedi i test di seguito.

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%

Ho trovato una soluzione elegante di http://dobrzanski.net/2009/05/05/14/c-decimaltostring-and-how-to-get-rid-of-trailing-zeros/

Fondamentalmente

decimal v=2.4200M;

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

Un approccio di livello molto basso, ma credo che questo sarebbe il modo più performante usando solo calcoli interi rapidi (e nessun metodo di analisi delle stringhe lento e metodi sensibili alla cultura):

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

Questo funzionerà:

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

O se il tuo valore iniziale è string:

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

Presta attenzione a questo commento .

Questo è semplice

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

Provato.

Saluti :)

Dipende da cosa rappresenta il tuo numero e come vuoi gestire i valori: è una valuta, hai bisogno di arrotondamenti o troncamenti, hai bisogno di questi arrotondamenti solo per la visualizzazione?

Se per la visualizzazione prendere in considerazione la formattazione, i numeri sono x.ToString ("")

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

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

Se si tratta solo di arrotondamento, utilizzare il sovraccarico Math.Round che richiede un sovraccarico MidPointRounding

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

Se ottieni il tuo valore da un database, considera il casting invece della conversione: double value = (decimal) myRecord ["columnName"];

Puoi semplicemente impostare come:

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

Nel caso in cui si desideri mantenere il numero decimale, provare il seguente esempio:

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

Prova di fare una soluzione più amichevole di 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());
}

Produzione:

=>1
=>1.000000023
=>1.000000023
=>

La risposta molto semplice è usare TrimEnd (). Ecco il risultato,

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

L'output è 1 Se il mio valore è 1.01, l'output sarà 1.01

Il seguente codice potrebbe essere utilizzato per non utilizzare il tipo di stringa:

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

Restituisce 789,5

Troncare gli zeri finali è molto semplice, risolvere con un cast duplex:

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

(I) -> Valore decimale di analisi da qualsiasi origine stringa.

(II) -> Primo: Cast per raddoppiare questo rimuovere gli zeri finali. Secondo: altro cast in decimale perché non esiste una conversione implicita da decimale a doppio e viceversa)

prova questo codice:

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

prova così

string s = "2.4200";

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

e poi convertilo in float