Как определить, является ли десятичное / двойное число целым числом?

Как мне узнать, является ли десятичное или двойное значение целым числом?

Например:

decimal d = 5.0; // Would be true
decimal f = 5.5; // Would be false

или

double d = 5.0; // Would be true
double f = 5.5; // Would be false

Поэтому я хотел бы знать , что это так , что я могу определить программно , если я хочу , чтобы вывести значение , используя .ToString("N0")или .ToString("N2"). Если нет десятичного значения, то я не хочу показывать это.

Для чисел с плавающей запятой, n % 1 == 0как правило, это способ проверить, есть ли что-нибудь после десятичной запятой.

public static void Main (string[] args)
{
    decimal d = 3.1M;
    Console.WriteLine((d % 1) == 0);
    d = 3.0M;
    Console.WriteLine((d % 1) == 0);
}

Вывод:

False
True

Обновление: как @Adrian Lopez упомянул ниже, сравнение с небольшим значениемepsilonотброситневерныевычисления с плавающей запятой. Поскольку вопрос касаетсяdoubleзначений, ниже будет более надежный ответ с вычислением с плавающей точкой :

Math.Abs(d % 1) <= (Double.Epsilon * 100)

Есть несколько способов сделать это. Например:

double d = 5.0;
bool isInt = d == (int)d;

Вы также можете использовать по модулю.

double d = 5.0;
bool isInt = d % 1 == 0;

Как насчет этого?

public static bool IsInteger(double number) {
    return number == Math.Truncate(number);
}

Тот же код для decimal.

На самом деле Марк Байерс высказал хорошую мысль: это может быть не тем, чего вы действительно хотите. Если вас действительно волнует, является ли число, округленное до двух десятичных знаков, целым числом , вы можете сделать это вместо этого:

public static bool IsNearlyInteger(double number) {
    return Math.Round(number, 2) == Math.Round(number);
}

В то время как предлагаемые решения работают на простых примерах, делать это в целом - плохая идея. Число может не быть целым числом, но когда вы пытаетесь отформатировать его, оно достаточно близко к целому числу, которое вы получаете 1.000000. Это может произойти, если вы выполните вычисление, которое в теории должно давать ровно 1, но на практике дает число, очень близкое, но не точно равное единице, из-за ошибок округления.

Вместо этого сначала отформатируйте его, и если ваша строка заканчивается точкой, за которой следуют нули, то удалите их. Есть также некоторые форматы, в которых вы можете автоматически использовать конечные нули. Это может быть достаточно для вашей цели.

double d = 1.0002;
Console.WriteLine(d.ToString("0.##"));
d = 1.02;
Console.WriteLine(d.ToString("0.##"));

Вывод:

1
1.02

bool IsInteger(double num) {
    if (ceil(num) == num && floor(num) == num)
        return true;
    else
        return false;
}

Проблема решения.

Редактировать: Pwned Марк Рушаков.

Ответ Марка Рушакова может быть проще, но следующие также работают и могут быть более эффективными, поскольку не существует неявной операции деления:

     bool isInteger = (double)((int)f) == f ;

и

     bool isInteger = (decimal)((int)d) == d ;

Если вы хотите одно выражение для обоих типов, возможно,

     bool isInteger = (double)((int)val) == (double)val ;

Если верхняя и нижняя граница Int32имеет значение:

public bool IsInt32(double value)
{
    return  value >= int.MinValue && value <= int.MaxValue && value == (int)value;
}

static bool IsWholeNumber(double x) 
{
    return Math.Abs(x % 1) < double.Epsilon;
}

Вы можете использовать форматирование String для типа double. Вот пример:

double val = 58.6547;
String.Format("{0:0.##}", val);      
//Output: "58.65"

double val = 58.6;
String.Format("{0:0.##}", val);      
//Output: "58.6"

double val = 58.0;
String.Format("{0:0.##}", val);      
//Output: "58"

Дайте мне знать, если это не поможет.

    public static bool isInteger(decimal n)
    {
        return n - (Int64)n == 0;
    }

Я сталкивался с подобной ситуацией, но где значение представляет собой строку. Пользователь вводит значение, которое должно быть в долларах, поэтому я хочу проверить, что оно числовое и имеет не более двух знаков после запятой.

Вот мой код для возврата true, если строка «s» представляет собой число с максимум двумя десятичными разрядами, и false в противном случае. Это позволяет избежать любых проблем, которые могут возникнуть в результате неточности значений с плавающей запятой.

try
{
    // must be numeric value
    double d = double.Parse(s);
    // max of two decimal places
    if (s.IndexOf(".") >= 0)
    {
        if (s.Length > s.IndexOf(".") + 3)
            return false;
    }
    return true;
catch
{
    return false;
}

Я обсуждаю это более подробно на http://progblog10.blogspot.com/2011/04/determining-whether-numeric-value-has.html .

Использование int.TryParse даст следующие результаты:

        var shouldBeInt = 3;

        var shouldntBeInt = 3.1415;

        var iDontWantThisToBeInt = 3.000f;

        Console.WriteLine(int.TryParse(shouldBeInt.ToString(), out int parser)); // true

        Console.WriteLine(int.TryParse(shouldntBeInt.ToString(), out parser)); // false

        Console.WriteLine(int.TryParse(iDontWantThisToBeInt.ToString(), out parser)); // true, even if I don't want this to be int

        Console.WriteLine(int.TryParse("3.1415", out  parser)); // false

        Console.WriteLine(int.TryParse("3.0000", out parser)); // false

        Console.WriteLine(int.TryParse("3", out parser)); // true

        Console.ReadKey();

Возможно, не самое элегантное решение, но оно работает, если вы не слишком разборчивы!

bool IsInteger(double num) {
    return !num.ToString("0.################").Contains(".");
}

Вы можете использовать метод TryParse.

int.TryParse()

Это проверяет, можно ли преобразовать значение в целое число. Затем результат может указывать флаг, который можно использовать в другом месте вашего кода.

Попробуй это:

number == Convert.ToInt16(number);