Como determinar se um decimal / duplo é um número inteiro?

Como saber se um valor decimal ou duplo é um número inteiro?

Por exemplo:

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

ou

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

A razão pela qual gostaria de saber isso é para que eu possa determinar programaticamente se quero gerar o valor usando .ToString("N0")or .ToString("N2"). Se não houver valor de ponto decimal, não quero mostrar isso.

Para números de ponto flutuante, n % 1 == 0normalmente é a maneira de verificar se há algo além do ponto decimal.

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

Resultado:

False
True

Atualização: Como o @Adrian Lopez mencionou abaixo, a comparação com um valor pequenoepsilondescartará erros de cálculo da computação em ponto flutuante. Como a pergunta é sobredoublevalores, abaixo será apresentada umaresposta mais à prova de cálculo de ponto flutuante :

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

Existem várias maneiras de fazer isso. Por exemplo:

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

Você também pode usar o módulo.

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

Que tal agora?

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

O mesmo código para decimal.

Mark Byers fez um bom argumento, na verdade: isso pode não ser o que você realmente deseja. Se você realmente gosta de saber se um número arredondado para as duas casas decimais mais próximas é um número inteiro , você pode fazer isso:

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

Embora as soluções propostas pareçam funcionar com exemplos simples, fazer isso em geral é uma má idéia. Um número pode não ser exatamente um número inteiro, mas quando você tenta formatá-lo, é próximo o suficiente de um número inteiro que você obtém 1.000000. Isso pode acontecer se você fizer um cálculo que, em teoria, deve fornecer exatamente 1, mas, na prática, fornece um número muito próximo, mas não exatamente igual a um, devido a erros de arredondamento.

Em vez disso, formate-o primeiro e, se sua string terminar em um período seguido por zeros, retire-os. Também existem alguns formatos que você pode usar para remover zeros à direita automaticamente. Isso pode ser bom o suficiente para o seu propósito.

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

Resultado:

1
1.02

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

Problemo solvo.

Edit: Pwned por Mark Rushakoff.

A resposta de Mark Rushakoff pode ser mais simples, mas o seguinte também funciona e pode ser mais eficiente, pois não há operação implícita de divisão:

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

e

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

Se você deseja uma única expressão para os dois tipos, talvez

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

Se o limite superior e inferior da Int32questão:

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

Você pode usar a formatação de seqüência de caracteres para o tipo duplo. Aqui está um exemplo:

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"

Deixe-me saber se isso não ajuda.

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

Eu enfrentei uma situação semelhante, mas onde o valor é uma string. O usuário digita um valor que deveria ser uma quantia em dólar, então quero validar que é numérico e tem no máximo duas casas decimais.

Aqui está o meu código para retornar true se a string "s" representar um numérico com no máximo duas casas decimais e false caso contrário. Evita quaisquer problemas que resultariam da imprecisão dos valores de ponto flutuante.

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

Discuto isso com mais detalhes em http://progblog10.blogspot.com/2011/04/determining-whether-numeric-value-has.html .

Usar int.TryParse produzirá estes resultados:

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

Talvez não seja a solução mais elegante, mas funciona se você não for muito exigente!

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

Você pode usar o método 'TryParse'.

int.TryParse()

Isso verifica se o valor pode ser convertido em um número inteiro inteiro. O resultado pode indicar um sinalizador que pode ser usado em outro lugar no seu código.

Tente o seguinte:

number == Convert.ToInt16(number);