Überprüfen, ob ein Objekt eine Zahl in C # ist

Ich möchte überprüfen , ob ein Objekt eine Zahl ist , so dass .ToString()in einem String führen würde enthalten Ziffern und +, -,.

Ist es durch einfaches Typprüfen in .net möglich (wie :) if (p is Number)?

Oder sollte ich in einen String konvertieren und dann versuchen, ihn zu verdoppeln?

Update: Um zu verdeutlichen, dass mein Objekt int, uint, float, double usw. ist, ist es keine Zeichenfolge. Ich versuche eine Funktion zu erstellen, die jedes Objekt wie folgt in XML serialisiert:

<string>content</string>

oder

<numeric>123.3</numeric>

oder eine Ausnahme auslösen.

Sie müssen lediglich eine Typprüfung für jeden der numerischen Grundtypen durchführen.

Hier ist eine Erweiterungsmethode, die den Job erledigen sollte:

public static bool IsNumber(this object value)
{
    return value is sbyte
            || value is byte
            || value is short
            || value is ushort
            || value is int
            || value is uint
            || value is long
            || value is ulong
            || value is float
            || value is double
            || value is decimal;
}

Dies sollte alle numerischen Typen abdecken.

Aktualisieren

Es scheint, dass Sie die Nummer während der Deserialisierung tatsächlich aus einer Zeichenfolge analysieren möchten. In diesem Fall wäre es wahrscheinlich am besten zu verwenden double.TryParse.

string value = "123.3";
double num;
if (!double.TryParse(value, out num))
    throw new InvalidOperationException("Value is not a number.");

Natürlich würde dies nicht mit sehr großen ganzen Zahlen / langen Dezimalstellen umgehen, aber wenn dies der Fall ist, müssen Sie nur zusätzliche Aufrufe zu long.TryParse/ decimal.TryParse/ was auch immer hinzufügen .

Entnommen aus Scott Hanselmans Blog :

public static bool IsNumeric(object expression)
{
    if (expression == null)
    return false;

    double number;
    return Double.TryParse( Convert.ToString( expression
                                            , CultureInfo.InvariantCulture)
                          , System.Globalization.NumberStyles.Any
                          , NumberFormatInfo.InvariantInfo
                          , out number);
}

Nutzen Sie die IsPrimitive-Eigenschaft, um eine praktische Erweiterungsmethode zu erstellen:

public static bool IsNumber(this object obj)
{
    if (Equals(obj, null))
    {
        return false;
    }

    Type objType = obj.GetType();
    objType = Nullable.GetUnderlyingType(objType) ?? objType;

    if (objType.IsPrimitive)
    {
        return objType != typeof(bool) && 
            objType != typeof(char) && 
            objType != typeof(IntPtr) && 
            objType != typeof(UIntPtr);
    }

    return objType == typeof(decimal);
}

BEARBEITEN: Gemäß Kommentaren behoben. Die Generika wurden entfernt, da die Werttypen .GetType () Felder sind. Ebenfalls enthaltener Fix für nullbare Werte.

Es gibt einige gute Antworten oben. Hier ist eine All-in-One-Lösung. Drei Überlastungen für unterschiedliche Umstände.

// Extension method, call for any object, eg "if (x.IsNumeric())..."
public static bool IsNumeric(this object x) { return (x==null ? false : IsNumeric(x.GetType())); }

// Method where you know the type of the object
public static bool IsNumeric(Type type) { return IsNumeric(type, Type.GetTypeCode(type)); }

// Method where you know the type and the type code of the object
public static bool IsNumeric(Type type, TypeCode typeCode) { return (typeCode == TypeCode.Decimal || (type.IsPrimitive && typeCode != TypeCode.Object && typeCode != TypeCode.Boolean && typeCode != TypeCode.Char)); }

Anstatt Ihre eigenen zu rollen, ist die zuverlässigste Methode, um festzustellen, ob ein eingebauter Typ numerisch ist, wahrscheinlich das Referenzieren Microsoft.VisualBasicund Aufrufen Information.IsNumeric(object value). Die Implementierung behandelt eine Reihe subtiler Fälle wie char[]HEX- und OCT-Zeichenfolgen.

Dort gibt es drei verschiedene Konzepte:

• Um zu überprüfen, ob es sich um eine Zahl handelt (dh um einen (normalerweise mit einem Kästchen versehenen) numerischen Wert selbst), überprüfen Sie den Typ beispielsweise mit is-if(obj is int) {...}
• um zu überprüfen, ob eine Zeichenfolge als Zahl analysiert werden kann; verwendenTryParse()
• Wenn das Objekt jedoch keine Zahl oder Zeichenfolge ist, Sie jedoch den Verdacht haben ToString(), dass es etwas gibt, das wie eine Zahl aussieht , rufen Sie es auf ToString() und behandeln Sie es als Zeichenfolge

In beiden ersten beiden Fällen müssen Sie wahrscheinlich jeden zu unterstützenden numerischen Typ ( double/ decimal/ int) separat behandeln - jeder hat beispielsweise unterschiedliche Bereiche und Genauigkeiten.

Sie können sich auch Regex ansehen, um eine schnelle grobe Überprüfung zu erhalten.

Angenommen, Ihre Eingabe ist eine Zeichenfolge ...

Es gibt zwei Möglichkeiten:

benutze Double.TryParse ()

double temp;
bool isNumber = Double.TryParse(input, out temp);

Verwenden Sie Regex

 bool isNumber = Regex.IsMatch(input,@"-?\d+(\.\d+)?");

Sie könnten folgenden Code verwenden:

if (n is IConvertible)
  return ((IConvertible) n).ToDouble(CultureInfo.CurrentCulture);
else
  // Cannot be converted.

Wenn Ihr Objekt eine ist Int32, Single, Doubleusw. wird die Konvertierung durchführen. Ein String wird ebenfalls implementiert, IConvertibleaber wenn der String nicht in ein Double konvertierbar ist, FormatExceptionwird ein geworfen.

Wenn Ihre Anforderung wirklich ist

.ToString () würde zu einer Zeichenfolge führen, die Ziffern und +, -, enthält.

Wenn Sie double.TryParse verwenden möchten, müssen Sie die Überladung verwenden, die einen NumberStyles-Parameter verwendet, und sicherstellen, dass Sie die invariante Kultur verwenden.

Verwenden Sie beispielsweise für eine Zahl, die möglicherweise ein führendes Vorzeichen, kein führendes oder nachfolgendes Leerzeichen, kein Tausendertrennzeichen und ein Dezimaltrennzeichen enthält:

NumberStyles style = 
   NumberStyles.AllowLeadingSign | 
   NumberStyles.AllowDecimalPoint | 
double.TryParse(input, style, CultureInfo.InvariantCulture, out result);

Beim Schreiben meiner eigenen object.IsNumeric()Erweiterungsmethode basierend auf der Antwort von Saul Dolgin auf diese Frage bin ich auf ein potenzielles Problem gestoßen, bei dem Sie eine erhalten, OverflowExceptionwenn Sie es mit double.MaxValueoder versuchen double.MinValue.

Meine "Lösung" bestand darin, die akzeptierte Antwort von Noldorin mit der von Saul Dolgin zu kombinieren und einen Mustervergleichsschalter hinzuzufügen, bevor ich versuchte, etwas zu analysieren (und etwas C # 7-Güte zu verwenden, um ein bisschen aufzuräumen):

public static bool IsNumeric(this object obj)
{
    if (obj == null) return false;

    switch (obj)
    {
        case sbyte _: return true;
        case byte _: return true;
        case short _: return true;
        case ushort _: return true;
        case int _: return true;
        case uint _: return true;
        case long _: return true;
        case ulong _: return true;
        case float _: return true;
        case double _: return true;
        case decimal _: return true;
    }

    string s = Convert.ToString(obj, CultureInfo.InvariantCulture);

    return double.TryParse(s, NumberStyles.Any, NumberFormatInfo.InvariantInfo, out double _);
}

Ja, das funktioniert:

object x = 1;
Assert.That(x is int);

Für eine Gleitkommazahl müssten Sie mit dem Gleitkommatyp testen:

object x = 1f;
Assert.That(x is float);