Xóa các số 0 ở cuối

Tôi có một số trường được trả về bởi một bộ sưu tập như

2.4200
2.0044
2.0000

Tôi muốn kết quả như

2.42
2.0044
2

Tôi đã thử với String.Format, nhưng nó trả về 2.0000và thiết lập nó để làm N0tròn các giá trị khác.

Nó không đơn giản như thế này, nếu đầu vào là một chuỗi? Bạn có thể sử dụng một trong những điều sau đây:

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

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

2.0m.ToString("G29")

Điều này sẽ làm việc cho tất cả các đầu vào.

Cập nhật Kiểm tra các định dạng số chuẩn mà tôi phải đặt rõ ràng bộ xác định chính xác thành 29 vì các tài liệu nêu rõ:

Tuy nhiên, nếu số là số thập phân và bộ xác định chính xác bị bỏ qua, ký hiệu điểm cố định luôn được sử dụng và các số 0 ở cuối được giữ nguyên

Cập nhật Konrad chỉ ra trong các ý kiến:

Coi chừng các giá trị như 0,000001. Định dạng G29 sẽ trình bày chúng theo cách ngắn nhất có thể để nó sẽ chuyển sang ký hiệu số mũ. string.Format("{0:G29}", decimal.Parse("0.00000001",System.Globalization.CultureInfo.GetCultureInfo("en-US")))sẽ cho kết quả "1E-08".

Tôi gặp vấn đề tương tự nhưng trong trường hợp tôi không kiểm soát được đầu ra thành chuỗi, được một thư viện chăm sóc. Sau khi xem xét chi tiết trong việc triển khai loại Thập phân (xem http://msdn.microsoft.com/en-us/l Library / system.decimal.getbits.aspx ), tôi đã nghĩ ra một mẹo gọn gàng (ở đây là một tiện ích mở rộng phương pháp):

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

Phần số mũ của số thập phân được giảm xuống chỉ còn những gì cần thiết. Gọi ToString () trên số thập phân đầu ra sẽ ghi số mà không có dấu nào 0. Ví dụ

1.200m.Normalize().ToString();

Theo tôi, an toàn hơn khi sử dụng Chuỗi định dạng số tùy chỉnh .

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

Tôi sử dụng mã này để tránh ký hiệu khoa học "G29":

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

EDIT: sử dụng hệ thống CultureInfo.NumberFormat.NumberDecimalSpayator:

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

Sử dụng #biểu tượng băm ( ) để chỉ hiển thị dấu 0 khi cần thiết. Xem các bài kiểm tra dưới đây.

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%

Tôi tìm thấy một giải pháp tao nhã từ http://dobrzanski.net/2009/05/14/c-decimaltostring-and-how-to-get-rid-of-trailing-zeros/

Về cơ bản

decimal v=2.4200M;

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

Một cách tiếp cận ở mức độ rất thấp, nhưng tôi tin rằng đây sẽ là cách hiệu quả nhất bằng cách chỉ sử dụng các phép tính số nguyên nhanh (và không có phương pháp phân tích chuỗi và phân tích chuỗi chậm):

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

Điều này sẽ làm việc:

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

Hoặc nếu giá trị ban đầu của bạn là string:

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

Hãy chú ý đến nhận xét này .

Cái này đơn giản.

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

Thử nghiệm.

Chúc mừng :)

Phụ thuộc vào những gì số của bạn đại diện và cách bạn muốn quản lý các giá trị: đó có phải là tiền tệ không, bạn có cần làm tròn hoặc cắt bớt không, bạn có cần làm tròn số này chỉ để hiển thị không?

Nếu để hiển thị, hãy xem xét định dạng các số là x.ToString ("")

http://msdn.microsoft.com/en-us/l Library / dawawy9k.aspx và

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

Nếu nó chỉ làm tròn, hãy sử dụng quá tải Math.Round yêu cầu quá tải MidPointRounding

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

Nếu bạn nhận được giá trị của mình từ cơ sở dữ liệu, hãy xem xét việc truyền thay vì chuyển đổi: double value = (thập phân) myRecord ["cộtName"];

Bạn chỉ có thể đặt là:

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

Trong trường hợp bạn muốn giữ số thập phân, hãy thử ví dụ sau:

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

Đang cố gắng thực hiện giải pháp thân thiện hơn với DecimalToString ( https://stackoverflow.com/a 432486763/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());
}

Đầu ra:

=>1
=>1.000000023
=>1.000000023
=>

Câu trả lời rất đơn giản là sử dụng TrimEnd (). Đây là kết quả,

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

Đầu ra là 1 Nếu giá trị của tôi là 1,01 thì đầu ra của tôi sẽ là 1,01

Đoạn mã sau có thể được sử dụng để không sử dụng kiểu chuỗi:

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

Trả về 789,5

Cắt ngắn Zeros rất dễ dàng, giải quyết bằng cách sử dụng song công:

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

(I) -> Phân tích giá trị thập phân từ bất kỳ nguồn chuỗi nào.

(II) -> Đầu tiên: Đúc để nhân đôi số 0 này. Thứ hai: Truyền khác sang thập phân vì không tồn tại chuyển đổi ngầm định từ thập phân sang kép và ngược lại)

thử mã này:

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

thử như thế này

string s = "2.4200";

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

và sau đó chuyển đổi nó để nổi