С# Как отформатировать двойное и одно знаковое число без округления

Мне нужно отформатировать двойное значение до одного десятичного знака без округления.

double value = 3.984568438706
string result = "";

Я пробовал:

1)

result = value.ToString("##.##", System.Globalization.CultureInfo.InvariantCulture) + "%"; 
// returns 3.98%

2)

result = value.ToString("##.#", System.Globalization.CultureInfo.InvariantCulture) + "%"; 
// returns 4%

3)

 result = value.ToString("##.0", System.Globalization.CultureInfo.InvariantCulture) + "%"; 
 // returns 4.0%

4) (Следуя другим предложениям)

value = (value / 100);
result = String.Format("{0:P1}", Math.Truncate(value * 10000) / 10000);
// returns 4.0%

result = string.Format("{0:0.0%}",value); // returns 4.0%

Мне нужно отобразить значение 3.9%

Спасибо за любую помощь заранее.

Ответы

Ответ 1

result=string.Format("{0:0.0}",Math.Truncate(value*10)/10);

Ответ 2

Я бы применил метод утилиты для этого:

static double Truncate(double value, int digits)
{
    double mult = System.Math.Pow(10.0, digits);
    return System.Math.Truncate(value * mult) / mult;
}

Затем вы можете:

result = Truncate(value, 1).ToString("##.#", System.Globalization.CultureInfo.InvariantCulture) + "%";

Обратите внимание, что вы можете также хотеть Math.Floor вместо truncate - но это зависит от того, как вы хотите обработать отрицательные значения.

Ответ 3

ToString() этого не делает. Вы должны добавить дополнительный код. Другие ответы показывают математические подходы, мой подход ниже - это внешний вид.

string result = value.ToString();
Console.WriteLine("{0}", result.Substring(0,result.LastIndexOf('.')+2));

Это довольно простой подход грубой силы, но он делает трюк, когда десятичное число является символом ".". Здесь используется метод расширения для облегчения боли (и имеет дело с десятичной точкой).

public static class Extensions
{
    public static string ToStringNoTruncate(this double me, int decimalplaces = 1)
    {
        string result = me.ToString();
        char dec = System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator[0];
        return result.Substring(0, result.LastIndexOf(dec) + decimalplaces + 1);
    }
}

Ответ 4

( Math.Truncate( ( value * 10 ) ) / 1000 ).ToString( "#.#%" )

Ответ 5

Просто используйте modulo operator + встроенный ToString:

result = (value - (value % 0.1)).ToString("N1") + "%";

Ответ 6

Я знаю, что это старый поток, но я просто должен был это сделать. В то время как подходы здесь работают, я хочу, чтобы простой способ повлиять на множество вызовов, поэтому использование Math.Truncate во всех вызовах string.format было не очень хорошим вариантом.

Таким образом, я создал поставщик пользовательских форматов, который позволил бы мне добавить усечение в строку форматирования, например

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

Реализация довольно проста и легко распространяется на другие требования.

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