Làm cách nào để định dạng số thập phân C# để loại bỏ thêm sau 0?

Question

Tôi muốn định dạng một chuỗi dưới dạng số thập phân, nhưng số thập phân chứa một số số sau sau dấu thập phân. Làm cách nào để định dạng nó sao cho những 0 vô nghĩa đó biến mất?

string.Format("{0}", 1100M); 
string.Format("{0}", 1100.1M); 
string.Format("{0}", 1100.100M); 
string.Format("{0}", 1100.1000M); 

hiển thị:

1100 
1100.1 
1100.100 
1100.1000 

nhưng tôi muốn nó được:

1100 
1100.1 
1100.1 
1100.1 

Để tham khảo, đây là những câu hỏi khác mà chủ yếu là bản sao của này, mà tôi đã tìm thấy nhờ cho câu trả lời được cung cấp tại đây:

• Parse decimal and filter extra 0 on the right?
• Best way to display decimal without trailing zeroes
• How can I strip zeros and decimal points off of decimal strings?

Answer 1

Bạn có thể sử dụng ToString() với General ("G") Format Specifier để đạt được kết quả mong muốn . Các số 0 được cắt bớt khi sử dụng chuỗi định dạng này với độ chính xác được chỉ định. Để tránh làm tròn trong bất kỳ tình huống nào, bạn sẽ cần đặt độ chính xác thành số thập phân tối đa được phép (29).

Dòng mã để tạo ra thứ bạn muốn là number.ToString("G29"), trong đó number là số thập phân ban đầu của bạn.

Lưu ý rằng bất kỳ số nào nhỏ hơn 0,0001 sẽ được chuyển đổi thành ký hiệu khoa học. Thông tin chi tiết về cách thức hoạt động của trình định dạng này có thể tìm thấy tại liên kết tham chiếu ở trên.

Answer 2

Bạn có thể chỉ định format string như thế này:

String.Format("{0:0.000}", x); 

Answer 3

String.Format("{0:0.##}", 123.0); // "123" 

Answer 4

Họ không nhất thiết phải vô nghĩa - họ chỉ ra chính xác trong tính toán. Số thập phân duy trì mức độ chính xác của chúng, thay vì được chuẩn hóa.

Tôi có một số mã trong this answer sẽ trả lại giá trị được chuẩn hóa - bạn có thể sử dụng giá trị đó và sau đó định dạng kết quả. Ví dụ:

using System; 
using System.Numerics; 

class Test 
{ 
    static void Display(decimal d) 
    { 
     d = d.Normalize(); // Using extension method from other post 
     Console.WriteLine(d); 
    } 

    static void Main(string[] args) 
    { 
     Display(123.4567890000m); // Prints 123.456789 
     Display(123.100m);  // Prints 123.1 
     Display(123.000m);  // Prints 123 
     Display(123.4567891234m); // Prints 123.4567891234 
    } 
} 

tôi nghi ngờ rằng hầu hết các phương pháp tiếp cận chuỗi định dạng sẽ thất bại. Tôi đoán rằng một chuỗi định dạng là "0." và sau đó 28 # nhân vật sẽ làm việc, nhưng nó sẽ rất xấu xí ...

Answer 5

Tôi tin rằng bạn muốn làm:

var s = String.Format("{0:#####.###}"); 

Answer 6

Khá một vài câu trả lời rồi. Tôi thường tham khảo cheat này tấm: http://blog.stevex.net/string-formatting-in-csharp/

Answer 7

Hơi hackish, nhưng điều này sẽ làm việc:

decimal a = 100.00M; 
string strNumber = string.Format("{0}", a); 
Console.WriteLine(strNumber.Contains('.') ? strNumber.TrimEnd('0').TrimEnd('.') : strNumber); 

Answer 8

Làm thế nào về:

string FormatDecimal(decimal d) 
{ 
    const char point = System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator[0]; 
    string s = d.ToString(); 
    // if there's no decimal point, there's nothing to trim 
    if (!s.Contains(point) == -1) 
     return s; 
    // trim any trailing 0s, followed by the decimal point if necessary 
    return s.TrimEnd('0').TrimEnd(point); 
} 

Answer 9

string s = d.ToString("0.#############################"); 

Answer 10

double a = 1100.00 
double b =1100.1 
double c = 1100.100 
double d =1100.1000 

Remove last zero after point 


string stra = a.toString("0.00").TrimEnd('0').TrimEnd('.'); 
string strb = b.toString("0.00").TrimEnd('0').TrimEnd('.'); 
string strc = c.toString("0.00").TrimEnd('0').TrimEnd('.'); 
string strd = d.toString("0.00").TrimEnd('0').TrimEnd('.'); 

Output 

1100 
1100.1 
1100.1 
1100.1 

Answer 11

Không giống như những gì mọi người đề nghị sử dụng một specifier định dạng G tôi sẽ đề nghị sau đây để bảo vệ cả hai ngàn tách và dấu thập phân trong khi loại bỏ thêm số không dấu:

{0:#,#.##} 

Kết quả của việc này định dạng tốt hơn nhiều so với G trong hầu hết các trường hợp:

String.Format("{0:#,#.##}",25/2.4); 
10.42 

String.Format("{0:#,#.##}",1000000); 
1,000,000 

String.Format("{0:#,#.##}",1000000.3600000); 
1,000,000.36 

An d Các thông số G không thể thực sự xử lý tất cả các kết hợp có thể có:

String.Format("{0:G29}",25/2.4); 
10.416666666666668 

String.Format("{0:G2}",25/2.4); 
10 

String.Format("{0:G29}",1000000.3600000); 
1000000.36 

String.Format("{0:G2}",1000000.3600000); 
1E+06