Wie kann man feststellen, ob eine Dezimalzahl / ein Doppel eine ganze Zahl ist?

Wie kann ich feststellen, ob ein Dezimal- oder Doppelwert eine Ganzzahl ist?

Beispielsweise:

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

oder

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

Der Grund, warum ich dies wissen möchte, ist, dass ich programmgesteuert bestimmen kann, ob ich den Wert mit .ToString("N0")oder ausgeben möchte .ToString("N2"). Wenn es keinen Dezimalpunktwert gibt, möchte ich das nicht zeigen.

Bei Gleitkommazahlen n % 1 == 0wird normalerweise überprüft, ob der Dezimalpunkt überschritten wird.

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

Ausgabe:

False
True

Update: Wie unten bei @Adrian Lopez erwähnt, werden beim Vergleich mit einem kleinen WertepsilonGleitkomma-Berechnungsfehlberechnungen verworfen. Da es sich bei der Frage umdoubleWerte handelt, finden Sie im Folgenden eineAntwort mitmehr Gleitkomma-Berechnungsnachweisen :

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

Es gibt verschiedene Möglichkeiten, dies zu tun. Beispielsweise:

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

Sie können auch Modulo verwenden.

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

Wie wäre es damit?

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

Gleicher Code für decimal.

Mark Byers machte tatsächlich einen guten Punkt: Dies ist möglicherweise nicht das, was Sie wirklich wollen. Wenn es Ihnen wirklich wichtig ist, ob eine auf die nächsten zwei Dezimalstellen gerundete Zahl eine Ganzzahl ist , können Sie stattdessen Folgendes tun:

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

Während die vorgeschlagenen Lösungen für einfache Beispiele zu funktionieren scheinen, ist dies im Allgemeinen eine schlechte Idee. Eine Zahl ist möglicherweise nicht genau eine Ganzzahl, aber wenn Sie versuchen, sie zu formatieren, liegt sie nahe genug an einer Ganzzahl, die Sie erhalten 1.000000. Dies kann passieren, wenn Sie eine Berechnung durchführen, die theoretisch genau 1 ergeben sollte, in der Praxis jedoch aufgrund von Rundungsfehlern eine Zahl ergibt, die sehr nahe an einer liegt, aber nicht genau gleich eins ist.

Formatieren Sie es stattdessen zuerst. Wenn Ihre Zeichenfolge in einem Punkt gefolgt von Nullen endet, entfernen Sie sie. Es gibt auch einige Formate, in denen Sie diese nachgestellten Nullen automatisch verwenden können. Dies könnte für Ihren Zweck gut genug sein.

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

Ausgabe:

1
1.02

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

Problemo solvo.

Edit: Pwned von Mark Rushakoff.

Mark Rushakoffs Antwort mag einfacher sein, aber die folgenden funktionieren auch und sind möglicherweise effizienter, da es keine implizite Teilungsoperation gibt:

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

und

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

Wenn Sie vielleicht einen einzigen Ausdruck für beide Typen wünschen

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

Wenn Ober- und Untergrenze von Int32Angelegenheiten:

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

Sie können die Zeichenfolgenformatierung für den Doppeltyp verwenden. Hier ist ein Beispiel:

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"

Lassen Sie mich wissen, wenn dies nicht hilft.

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

Ich sah mich einer ähnlichen Situation gegenüber, aber wo der Wert eine Zeichenfolge ist. Der Benutzer gibt einen Wert ein, der ein Dollarbetrag sein soll. Daher möchte ich überprüfen, ob er numerisch ist und höchstens zwei Dezimalstellen hat.

Hier ist mein Code, der true zurückgibt, wenn die Zeichenfolge "s" eine Zahl mit höchstens zwei Dezimalstellen darstellt, andernfalls false. Es werden Probleme vermieden, die sich aus der Ungenauigkeit von Gleitkommawerten ergeben würden.

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

Ich diskutiere dies ausführlicher unter http://progblog10.blogspot.com/2011/04/determining-whether-numeric-value-has.html .

Die Verwendung von int.TryParse führt zu folgenden Ergebnissen:

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

Vielleicht nicht die eleganteste Lösung, aber es funktioniert, wenn Sie nicht zu wählerisch sind!

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

Sie können die Methode 'TryParse' verwenden.

int.TryParse()

Dies prüft, ob der Wert in einen ganzzahligen Ganzzahlwert konvertiert werden kann. Das Ergebnis kann dann ein Flag anzeigen, das an anderer Stelle in Ihrem Code verwendet werden kann.

Versuche dies:

number == Convert.ToInt16(number);