ลบเลขศูนย์ต่อท้าย

ฉันมีบางฟิลด์ที่ส่งคืนโดยคอลเล็กชันเป็น

2.4200
2.0044
2.0000

ฉันต้องการผลลัพธ์เช่น

2.42
2.0044
2

ฉันลองด้วยString.Formatแต่มันกลับมา2.0000และตั้งค่าให้N0ปัดเศษค่าอื่นเช่นกัน

มันไม่ง่ายอย่างนี้ถ้าอินพุตเป็นสตริงหรือไม่? คุณสามารถใช้หนึ่งในเหล่านี้:

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

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

2.0m.ToString("G29")

สิ่งนี้ควรใช้กับอินพุตทั้งหมด

อัปเดตตรวจสอบรูปแบบตัวเลขมาตรฐานฉันต้องตั้งค่าตัวระบุความแม่นยำเป็น 29 อย่างชัดเจนเนื่องจากเอกสารระบุอย่างชัดเจน:

อย่างไรก็ตามถ้าตัวเลขเป็นทศนิยมและตัวระบุความแม่นยำถูกละเว้นเครื่องหมายจุดคงที่จะใช้เสมอและเลขศูนย์ต่อท้ายจะถูกเก็บไว้

อัพเดท Konrad ชี้ให้เห็นในความคิดเห็น:

ระวังค่าเช่น 0.000001 รูปแบบ G29 จะนำเสนอด้วยวิธีที่สั้นที่สุดเท่าที่จะเป็นไปได้ดังนั้นจึงจะเปลี่ยนเป็นสัญลักษณ์แบบเอ็กซ์โปเนนเชียล string.Format("{0:G29}", decimal.Parse("0.00000001",System.Globalization.CultureInfo.GetCultureInfo("en-US")))จะให้ผลลัพธ์เป็น "1E-08"

ฉันพบปัญหาเดียวกัน แต่ในกรณีที่ฉันไม่สามารถควบคุมเอาต์พุตไปยังสตริงได้ซึ่งไลบรารีได้รับการดูแล หลังจากดูรายละเอียดในการใช้งานประเภททศนิยม (ดูที่http://msdn.microsoft.com/en-us/library/system.decimal.getbits.aspx ) ฉันคิดขึ้นมาอย่างประณีต (นี่เป็นส่วนเสริม วิธี):

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

ส่วนเลขชี้กำลังของทศนิยมจะลดลงเหลือเพียงส่วนที่ต้องการ การเรียก ToString () บนทศนิยมเอาท์พุทจะเขียนหมายเลขโดยไม่มีการต่อท้าย 0 เช่น

1.200m.Normalize().ToString();

ในความคิดของฉันที่ปลอดภัยในการใช้งานที่กำหนดเองตัวเลขสตริงรูปแบบ

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

ฉันใช้รหัสนี้เพื่อหลีกเลี่ยงสัญลักษณ์ทางวิทยาศาสตร์ "G29":

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

แก้ไข: การใช้ระบบ 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;
}

ใช้#สัญลักษณ์hash ( ) เพื่อแสดง 0 ต่อท้ายเมื่อจำเป็นเท่านั้น ดูการทดสอบด้านล่าง

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-traos/

เป็นพื้น

decimal v=2.4200M;

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

วิธีการระดับต่ำมาก แต่ฉันเชื่อว่านี่จะเป็นวิธีที่มีประสิทธิภาพมากที่สุดโดยใช้การคำนวณจำนวนเต็มอย่างรวดเร็วเท่านั้น (และไม่มีวิธีการแยกสตริงที่ช้าและวิธีการไวต่อวัฒนธรรม):

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

สิ่งนี้จะได้ผล:

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

หรือถ้าค่าเริ่มต้นของคุณคือstring:

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

ให้ความสนใจกับความคิดเห็นนี้

มันง่ายมาก

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

ผ่านการทดสอบ

ไชโย :)

ขึ้นอยู่กับว่าหมายเลขของคุณเป็นอย่างไรและคุณต้องการจัดการค่าอย่างไร: เป็นสกุลเงินคุณต้องการปัดเศษหรือตัดปลายคุณต้องการปัดเศษนี้เพื่อแสดงหรือไม่

หากการแสดงพิจารณาพิจารณาการจัดรูปแบบตัวเลขเป็น x.ToString ("")

http://msdn.microsoft.com/en-us/library/dwhawy9k.aspxและ

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

ถ้าเป็นเพียงการปัดเศษให้ใช้ Math.Round overload ที่ต้องการ MidpointRounding overload

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

หากคุณได้รับค่าจากฐานข้อมูลให้พิจารณาการส่งแทนการแปลง: double value = (ฐานสิบ) myRecord ["columnName"];

คุณสามารถตั้งค่าเป็น:

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

ในกรณีที่คุณต้องการเก็บตัวเลขทศนิยมให้ลองตัวอย่างต่อไปนี้:

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

พยายามทำโซลูชันที่เป็นมิตรกับ 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());
}

เอาท์พุท:

=>1
=>1.000000023
=>1.000000023
=>

คำตอบที่ง่ายมากคือการใช้ TrimEnd () นี่คือผลลัพธ์

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

เอาต์พุตคือ 1 ถ้าค่าของฉันคือ 1.01 ดังนั้นเอาต์พุตของฉันจะเป็น 1.01

รหัสต่อไปนี้สามารถใช้เพื่อไม่ใช้ชนิดสตริง:

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

ส่งคืน 789.5

ตัดศูนย์ที่ต่อท้ายง่ายมากแก้ไขด้วยการเพล็กซ์:

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

(I) -> แยกวิเคราะห์ค่าทศนิยมจากแหล่งสตริงใด ๆ

(II) -> แรก: ส่งไปที่สองนี้ลบศูนย์ต่อท้าย ที่สอง: คาสต์อื่น ๆ เป็นทศนิยมเพราะไม่มีการแปลงโดยนัยจากทศนิยมเป็นสองเท่าและเป็นตัวแทน)

ลองรหัสนี้:

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

ลองแบบนี้

string s = "2.4200";

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

แล้วแปลงมันให้ลอย