C # Double - formatowanie ToString () z dwoma miejscami dziesiętnymi, ale bez zaokrąglania

Jak sformatować a Doubledo a Stringw C #, aby mieć tylko dwa miejsca po przecinku?

Jeśli użyję String.Format("{0:0.00}%", myDoubleValue)liczby, jest ona zaokrąglana i chcę prostego obcięcia bez zaokrąglania. Chcę również, aby konwersja Stringbyła wrażliwa na kulturę.

Używam następujących:

double x = Math.Truncate(myDoubleValue * 100) / 100;

Na przykład:

Jeśli numer to 50.947563 i użyjesz tego, wydarzy się co następuje:

- Math.Truncate(50.947563 * 100) / 100;
- Math.Truncate(5094.7563) / 100;
- 5094 / 100
- 50.94

Twoja odpowiedź została obcięta, teraz, aby sformatować ciąg, wykonaj następujące czynności:

string s = string.Format("{0:N2}%", x); // No fear of rounding and takes the default number format

Następujące zaokrągla liczby, ale pokazuje tylko do 2 miejsc po przecinku (usuwając wszelkie końcowe zera), dzięki .##.

decimal d0 = 24.154m;
decimal d1 = 24.155m;
decimal d2 = 24.1m;
decimal d3 = 24.0m;

d0.ToString("0.##");   //24.15
d1.ToString("0.##");   //24.16 (rounded up)
d2.ToString("0.##");   //24.1  
d3.ToString("0.##");   //24

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

Proponuję najpierw obciąć, a następnie sformatować:

double a = 123.4567;
double aTruncated = Math.Truncate(a * 100) / 100;
CultureInfo ci = new CultureInfo("de-DE");
string s = string.Format(ci, "{0:0.00}%", aTruncated);

Użyj stałej 100 dla obcinania 2 cyfr; użyj 1, po którym następuje tyle zer, ile cyfr po przecinku chcesz. Użyj nazwy kultury, której potrzebujesz, aby dostosować wynik formatowania.

Najprostsza metoda, użyj ciągów formatu liczbowego:

double total = "43.257"
MessageBox.Show(total.ToString("F"));

używam price.ToString("0.00") do uzyskania wiodących zer

Funkcja C # wyrażona przez Kyle'a Rozendo:

string DecimalPlaceNoRounding(double d, int decimalPlaces = 2)
{
    d = d * Math.Pow(10, decimalPlaces);
    d = Math.Truncate(d);
    d = d / Math.Pow(10, decimalPlaces);
    return string.Format("{0:N" + Math.Abs(decimalPlaces) + "}", d);
}

Co powiesz na dodanie jednego dodatkowego miejsca po przecinku, który ma zostać zaokrąglony, a następnie odrzucony:

var d = 0.241534545765;
var result1 = d.ToString("0.###%");

var result2 = result1.Remove(result1.Length - 1);

To działa dla mnie

string prouctPrice = Convert.ToDecimal(String.Format("{0:0.00}", Convert.ToDecimal(yourString))).ToString();

Wiem, że to stary wątek, ale po prostu musiałem to zrobić. Podczas gdy inne podejścia tutaj działają, chciałem mieć łatwy sposób wpływania na wiele połączeń do string.format. Więc dodanie Math.Truncatedo wszystkich wywołań nie było dobrym rozwiązaniem. Ponadto, ponieważ część formatowania jest przechowywana w bazie danych, pogorszyło to jeszcze bardziej.

Dlatego stworzyłem niestandardowego dostawcę formatu, który pozwoliłby mi dodać obcinanie do ciągu formatującego, np .:

string.format(new FormatProvider(), "{0:T}", 1.1299); // 1.12
string.format(new FormatProvider(), "{0:T(3)", 1.12399); // 1.123
string.format(new FormatProvider(), "{0:T(1)0,000.0", 1000.9999); // 1,000.9

Implementacja jest dość prosta i można ją łatwo rozszerzyć na inne wymagania.

public class FormatProvider : IFormatProvider, ICustomFormatter
{
    public object GetFormat(Type formatType)
    {
        if (formatType == typeof (ICustomFormatter))
        {
            return this;
        }
        return null;
    }

    public string Format(string format, object arg, IFormatProvider formatProvider)
    {
        if (arg == null || arg.GetType() != typeof (double))
        {
            try
            {
                return HandleOtherFormats(format, arg);
            }
            catch (FormatException e)
            {
                throw new FormatException(string.Format("The format of '{0}' is invalid.", format));
            }
        }

        if (format.StartsWith("T"))
        {
            int dp = 2;
            int idx = 1;
            if (format.Length > 1)
            {
                if (format[1] == '(')
                {
                    int closeIdx = format.IndexOf(')');
                    if (closeIdx > 0)
                    {
                        if (int.TryParse(format.Substring(2, closeIdx - 2), out dp))
                        {
                            idx = closeIdx + 1;
                        }
                    }
                    else
                    {
                        throw new FormatException(string.Format("The format of '{0}' is invalid.", format));
                    }
                }
            }
            double mult = Math.Pow(10, dp);
            arg = Math.Truncate((double)arg * mult) / mult;
            format = format.Substring(idx);
        }

        try
        {
            return HandleOtherFormats(format, arg);
        }
        catch (FormatException e)
        {
            throw new FormatException(string.Format("The format of '{0}' is invalid.", format));
        }
    }

    private string HandleOtherFormats(string format, object arg)
    {
        if (arg is IFormattable)
        {
            return ((IFormattable) arg).ToString(format, CultureInfo.CurrentCulture);
        }
        return arg != null ? arg.ToString() : String.Empty;
    }
}

Miałem ten problem z Xamarin Forms i rozwiązałem go w ten sposób:

percent.ToString("0.##"+"%")

Do pokazania waluty możesz użyć "C":

double cost = 1.99;
m_CostText.text = cost.ToString("C"); /*C: format as currentcy */

Wynik: $1.99

Możesz także napisać własny IFormatProvider , chociaż przypuszczam, że w końcu będziesz musiał pomyśleć o sposobie wykonania faktycznego obcięcia.

NET Framework obsługuje również formatowanie niestandardowe. Zwykle wiąże się to z utworzeniem klasy formatowania, która implementuje zarówno IFormatProvider, jak i ICustomFormatter . (msdn)

Przynajmniej byłby łatwy do ponownego użycia.

W CodeProject znajduje się artykuł o tym, jak zaimplementować własny IFormatProvider / ICustomFormatter . W takim przypadku najlepszym rozwiązaniem może być „rozszerzenie” istniejącego formatu liczbowego. Nie wygląda to zbyt mocno.

Następujące mogą być używane tylko do wyświetlania, które używają właściwości String ..

double value = 123.456789;
String.Format("{0:0.00}", value);

Rozwiązanie:

var d = 0.123345678; 
var stringD = d.ToString(); 
int indexOfP = stringD.IndexOf("."); 
var result = stringD.Remove((indexOfP+1)+2);

(indexOfP + 1) +2 (ta liczba zależy od tego, ile liczb chcesz zachować. Daję dwa, ponieważ właściciel pytania chce).

Zwróć także uwagę na CultureInformation swojego systemu. Tutaj moje rozwiązanie bez zaokrąglania.

W tym przykładzie wystarczy zdefiniować zmienną MyValue jako double. W rezultacie otrzymasz sformatowaną wartość w zmiennej łańcuchowej NewValue .

Uwaga - ustaw również instrukcję C # using:

using System.Globalization;  

string MyFormat = "0";
if (MyValue.ToString (CultureInfo.InvariantCulture).Contains (CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator))
   {
      MyFormat += ".00";
   }

string NewValue = MyValue.ToString(MyFormat);