Come determinare se un decimale / doppio è un numero intero?

Come faccio a sapere se un valore decimale o doppio è un numero intero?

Per esempio:

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

o

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

Il motivo per cui vorrei saperlo è che posso determinare a livello di codice se voglio produrre il valore usando .ToString("N0")o .ToString("N2"). Se non esiste un valore in virgola decimale, non voglio mostrarlo.

Per i numeri in virgola mobile, n % 1 == 0è in genere il modo per verificare se c'è qualcosa oltre il punto decimale.

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

Produzione:

False
True

Aggiornamento: Come indicato da @Adrian Lopez di seguito, il confronto con un valore piccolo eliminerà i calcoli errati diepsiloncalcolo in virgola mobile. Poiché la domanda riguarda idoublevalori, di seguito verrà fornita una risposta di prova di calcolo in virgola mobile più:

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

Ci sono molti modi per farlo. Per esempio:

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

Puoi anche usare il modulo.

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

Cosa ne pensi di questo?

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

Stesso codice per decimal.

Mark Byers ha fatto un buon punto, in realtà: questo potrebbe non essere quello che vuoi davvero . Se quello che davvero interessa è se un numero arrotondato alle due decimali più vicine sia un numero intero , puoi invece farlo:

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

Mentre le soluzioni proposte sembrano funzionare per semplici esempi, farlo in generale è una cattiva idea. Un numero potrebbe non essere esattamente un numero intero ma quando provi a formattarlo, è abbastanza vicino a un numero intero che ottieni1.000000 . Questo può accadere se si esegue un calcolo che in teoria dovrebbe fornire esattamente 1, ma in pratica fornisce un numero molto vicino ma non esattamente uguale a uno a causa di errori di arrotondamento.

Invece, formattalo prima e se la stringa termina in un punto seguito da zeri, quindi rimuovili. Ci sono anche alcuni formati che puoi usare automaticamente per eliminare gli zeri finali. Questo potrebbe essere abbastanza buono per il tuo scopo.

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

Produzione:

1
1.02

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

Problemo solvo.

Modifica: presentato da Mark Rushakoff.

La risposta di Mark Rushakoff potrebbe essere più semplice, ma anche i seguenti funzionano e possono essere più efficienti poiché non vi sono operazioni di divisione implicite:

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

e

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

Se vuoi una singola espressione per entrambi i tipi, forse

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

Se il limite superiore e inferiore delle Int32materie:

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

È possibile utilizzare la formattazione String per il doppio tipo. Ecco un esempio:

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"

Fammi sapere se questo non aiuta.

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

Ho affrontato una situazione simile, ma in cui il valore è una stringa. L'utente digita un valore che dovrebbe essere un importo in dollari, quindi voglio confermare che è numerico e ha al massimo due cifre decimali.

Ecco il mio codice per restituire true se la stringa "s" rappresenta un valore numerico con al massimo due cifre decimali e false in caso contrario. Evita qualsiasi problema derivante dall'imprecisione dei valori in virgola mobile.

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

Ne discuterò in modo più dettagliato su http://progblog10.blogspot.com/2011/04/determining-whether-numeric-value-has.html .

L'uso di int.TryParse produrrà questi risultati:

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

Forse non è la soluzione più elegante ma funziona se non sei troppo esigente!

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

È possibile utilizzare il metodo "TryParse".

int.TryParse()

Questo verifica se il valore può essere convertito in un valore intero numero intero. Il risultato può quindi indicare una bandiera che può essere utilizzata altrove nel codice.

Prova questo:

number == Convert.ToInt16(number);