Hapus nol tertinggal

Saya memiliki beberapa bidang dikembalikan oleh koleksi sebagai

2.4200
2.0044
2.0000

Saya ingin hasil seperti

2.42
2.0044
2

Saya mencoba String.Format, tetapi mengembalikan 2.0000dan mengaturnya untuk N0membulatkan nilai-nilai lain juga.

Apakah tidak sesederhana ini, jika inputnya berupa string? Anda dapat menggunakan salah satu dari ini:

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

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

2.0m.ToString("G29")

Ini harus bekerja untuk semua input.

Perbarui Lihat Format Numerik Standar yang saya miliki untuk secara eksplisit mengatur specifier presisi ke 29 sebagai dokumen jelas menyatakan:

Namun, jika angka tersebut adalah Desimal dan specifier presisi dihilangkan, notasi titik tetap selalu digunakan dan nol trailing dipertahankan.

Pembaruan Konrad ditunjukkan dalam komentar:

Perhatikan nilai-nilai seperti 0,000001. Format G29 akan menyajikannya dengan cara sesingkat mungkin sehingga akan beralih ke notasi eksponensial. string.Format("{0:G29}", decimal.Parse("0.00000001",System.Globalization.CultureInfo.GetCultureInfo("en-US")))akan memberikan "1E-08" sebagai hasilnya.

Saya mengalami masalah yang sama tetapi dalam kasus di mana saya tidak memiliki kontrol output ke string, yang dirawat oleh perpustakaan. Setelah melihat detail penerapan tipe Desimal (lihat http://msdn.microsoft.com/en-us/library/system.decimal.getbits.aspx ), saya menemukan trik yang rapi (di sini sebagai ekstensi metode):

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

Bagian eksponen desimal dikurangi menjadi apa yang dibutuhkan. Memanggil ToString () pada desimal output akan menulis nomor tanpa tertinggal 0. Misalnya

1.200m.Normalize().ToString();

Menurut pendapat saya lebih aman menggunakan Custom Numeric Format String .

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

Saya menggunakan kode ini untuk menghindari notasi ilmiah "G29":

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

EDIT: using system 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;
}

Gunakan #simbol hash ( ) untuk hanya menampilkan trailing 0 bila perlu. Lihat tes di bawah ini.

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%

Saya menemukan solusi elegan dari http://dobrzanski.net/2009/05/14/c-decimaltostring-and-how-to-get-rid-of-trailing-zeros/

Pada dasarnya

decimal v=2.4200M;

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

Pendekatan level yang sangat rendah, tapi saya yakin ini akan menjadi cara yang paling performan dengan hanya menggunakan perhitungan integer cepat (dan tidak ada metode penguraian string lambat dan kultur sensitif):

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

Ini akan berhasil:

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

Atau jika nilai awal Anda adalah string:

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

Perhatikan komentar ini .

Ini sederhana.

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

Diuji.

Bersulang :)

Bergantung pada apa yang angka Anda wakili dan bagaimana Anda ingin mengelola nilai: apakah ini mata uang, apakah Anda perlu pembulatan atau pemotongan, apakah Anda perlu pembulatan ini hanya untuk tampilan?

Jika untuk tampilan pertimbangkan memformat angka-angka tersebut x.ToString ("")

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

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

Jika hanya pembulatan, gunakan kelebihan beban Math.Round yang membutuhkan kelebihan MidPointRounding

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

Jika Anda mendapatkan nilai dari basis data, pertimbangkan untuk menggunakan casting alih-alih konversi: double value = (desimal) myRecord ["columnName"];

Anda bisa menetapkan sebagai:

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

Jika Anda ingin menyimpan angka desimal, coba contoh berikut:

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

Mencoba melakukan solusi DecimalToString yang lebih ramah ( 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());
}

Keluaran:

=>1
=>1.000000023
=>1.000000023
=>

Jawaban yang sangat sederhana adalah dengan menggunakan TrimEnd (). Inilah hasilnya,

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

Output adalah 1 Jika nilai saya adalah 1,01 maka output saya akan menjadi 1,01

Kode berikut dapat digunakan untuk tidak menggunakan tipe string:

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

Pengembalian 789.5

Truncate trailing Zero sangat mudah, atasi dengan duplex cast:

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

(I) -> Parse nilai desimal dari sembarang sumber string.

(II) -> Pertama: Cast untuk menggandakan ini menghapus nol trailing. Kedua: Lainnya dilemparkan ke desimal karena tidak ada konversi implisit dari desimal ke ganda dan sebaliknya

coba kode ini:

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

coba seperti ini

string s = "2.4200";

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

dan kemudian mengubahnya menjadi mengambang