Sondaki sıfırları kaldır

Bir koleksiyon tarafından döndürülen bazı alanlar var

2.4200
2.0044
2.0000

Gibi sonuçlar istiyorum

2.42
2.0044
2

İle denedim String.Format, ama geri döner 2.0000ve N0diğer değerleri de yuvarlar.

Giriş bir dize IS ise, bu kadar basit değil mi? Bunlardan birini kullanabilirsiniz:

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

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

2.0m.ToString("G29")

Bu, tüm girdiler için çalışmalıdır.

Güncelleme Dokümanlar açıkça belirtildiği gibi, kesinlik belirtecini 29 olarak açıkça ayarlamak zorunda kaldığım Standart Sayısal Biçimlere göz atın :

Bununla birlikte, sayı Ondalık ise ve duyarlık belirtici atlanırsa, sabit nokta gösterimi her zaman kullanılır ve sondaki sıfırlar korunur

Konrad Güncellemesi yorumlarda belirtti :

0.000001 gibi değerlere dikkat edin. G29 formatı bunları mümkün olan en kısa şekilde sunacaktır, böylece üstel gösterime geçecektir. string.Format("{0:G29}", decimal.Parse("0.00000001",System.Globalization.CultureInfo.GetCultureInfo("en-US")))sonuç olarak "1E-08" verecektir.

Aynı sorunla karşılaştım ama bir kütüphane tarafından halledilen dizeye çıktı kontrolü olmayan bir durumda. Ondalık türün uygulanmasındaki ayrıntılara baktıktan sonra (bkz. Http://msdn.microsoft.com/en-us/library/system.decimal.getbits.aspx ), düzgün bir numara buldum (burada bir uzantı olarak) yöntem):

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

Ondalık sayının üssü tam olarak gereken şeye indirgenir. Çıktı ondalık biriminde ToString () çağrıldığında, numara herhangi bir iz olmadan 0 yazılır.

1.200m.Normalize().ToString();

Bence Özel Sayısal Biçim Dizeleri kullanmak daha güvenlidir .

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

"G29" bilimsel gösterim önlemek için bu kodu kullanın:

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

EDIT: sistem CultureInfo.NumberFormat.NumberDecimalSeparator kullanarak:

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

#Yalnızca gerektiğinde sondaki 0'ları görüntülemek için hash ( ) sembolünü kullanın. Aşağıdaki testlere bakın.

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%

Http://dobrzanski.net/2009/05/14/c-decimaltostring-and-how-to-get-rid-of-trailing-zeros/ adresinden zarif bir çözüm buldum.

temel olarak

decimal v=2.4200M;

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

Çok düşük seviyeli bir yaklaşım, ancak bunun sadece hızlı tamsayı hesaplamaları (ve yavaş dize ayrıştırma ve kültüre duyarlı yöntemler yok) kullanarak en performanslı yol olacağını düşünüyorum:

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

Bu çalışacak:

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

Veya başlangıç ​​değeriniz string:

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

Bu yoruma dikkat edin .

Bu basit.

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

Test edilmiştir.

Şerefe :)

Numaranızın neyi temsil ettiğine ve değerleri nasıl yönetmek istediğinize bağlıdır: bu bir para birimi mi, yuvarlama mı yoksa kesilmeye mi ihtiyacınız var, bu yuvarlamaya sadece görüntüleme için mi ihtiyacınız var?

Görüntüleme için sayıları biçimlendirmeyi düşünün x.ToString ("")

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

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

Sadece yuvarlanıyorsa, MidPointRounding aşırı yüklemesi gerektiren Math.Round aşırı yükünü kullanın

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

Değerinizi bir veritabanından alırsanız, dönüşüm yerine döküm yapmayı düşünün: double value = (ondalık) myRecord ["columnName"];

Sadece şu şekilde ayarlayabilirsiniz:

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

Ondalık sayıyı korumak istiyorsanız, aşağıdaki örneği deneyin:

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

Daha kolay DecimalToString çözümü yapmaya çalışıyorum ( 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());
}

Çıktı:

=>1
=>1.000000023
=>1.000000023
=>

Çok basit cevap TrimEnd () kullanmaktır. İşte sonuç,

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

Çıktı 1 ise Değerim 1.01 ise çıktım 1.01 olacak

Dize türünü kullanmamak için aşağıdaki kod kullanılabilir:

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

789,5 döndürür

Sondaki Zeros'u kısaltmak çok kolaydır, dubleks bir dökümle çözün:

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

(I) -> Herhangi bir dize kaynağından ondalık değeri ayrıştırın.

(II) -> İlk: Sondaki sıfırları kaldırmak için bunu iki katına çıkarın. İkincisi: Ondalıktan ikiye ve viceversa'ya örtük dönüşüm olmadığı için diğer ondalık sayıya dökülür)

bu kodu deneyin:

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

böyle dene

string s = "2.4200";

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

ve sonra bunu şamandıraya dönüştür