Identifizieren Sie, ob eine Zeichenfolge eine Zahl ist

Wenn ich diese Zeichenfolgen habe:

1. "abc" = false

2. "123" = true

3. "ab2" = false

Gibt es einen Befehl wie IsNumeric()oder etwas anderes, der erkennen kann, ob eine Zeichenfolge eine gültige Zahl ist?

int n;
bool isNumeric = int.TryParse("123", out n);

Update ab C # 7:

var isNumeric = int.TryParse("123", out int n);

oder wenn Sie die Nummer nicht benötigen, können Sie den out-Parameter verwerfen

var isNumeric = int.TryParse("123", out _);

Die var s können durch ihre jeweiligen Typen ersetzt werden!

Dies gibt true zurück, wenn inputalle Zahlen sind. Ich weiß nicht, ob es besser ist als TryParse, aber es wird funktionieren.

Regex.IsMatch(input, @"^\d+$")

Wenn Sie nur wissen möchten, ob eine oder mehrere Zahlen mit Zeichen gemischt sind, lassen Sie das ^ +und weg $.

Regex.IsMatch(input, @"\d")

Bearbeiten: Eigentlich denke ich, dass es besser ist als TryParse, weil eine sehr lange Zeichenfolge möglicherweise TryParse überlaufen könnte.

Sie können auch verwenden:

stringTest.All(char.IsDigit);

Es wird truefür alle numerischen Ziffern (nicht float) zurückgegeben und falsewenn die Eingabezeichenfolge eine alphanumerische Zeichenfolge ist.

Bitte beachten Sie : stringTestsollte keine leere Zeichenfolge sein, da dies den Test der Numerik bestehen würde.

Ich habe diese Funktion mehrmals verwendet:

public static bool IsNumeric(object Expression)
{
    double retNum;

    bool isNum = Double.TryParse(Convert.ToString(Expression), System.Globalization.NumberStyles.Any, System.Globalization.NumberFormatInfo.InvariantInfo, out retNum);
    return isNum;
}

Sie können aber auch verwenden;

bool b1 = Microsoft.VisualBasic.Information.IsNumeric("1"); //true
bool b2 = Microsoft.VisualBasic.Information.IsNumeric("1aa"); // false

Aus dem Benchmarking von isNumerischen Optionen

_{(Quelle: aspalliance.com )}

_{(Quelle: aspalliance.com )}

Dies ist wahrscheinlich die beste Option in C #.

Wenn Sie wissen möchten, ob die Zeichenfolge eine ganze Zahl (Ganzzahl) enthält:

string someString;
// ...
int myInt;
bool isNumerical = int.TryParse(someString, out myInt);

Die TryParse-Methode versucht, die Zeichenfolge in eine Zahl (Ganzzahl) zu konvertieren. Wenn dies erfolgreich ist, gibt sie true zurück und platziert die entsprechende Zahl in myInt. Wenn dies nicht möglich ist, wird false zurückgegeben.

Lösungen, die int.Parse(someString)die in anderen Antworten gezeigte Alternative verwenden, funktionieren, sind jedoch viel langsamer, da das Auslösen von Ausnahmen sehr teuer ist. TryParse(...)wurde der C # -Sprache in Version 2 hinzugefügt, und bis dahin hatten Sie keine Wahl. Jetzt tun Sie es: Sie sollten daher die Parse()Alternative vermeiden .

Wenn Sie Dezimalzahlen akzeptieren möchten, verfügt die Dezimalklasse auch über eine .TryParse(...)Methode. Ersetzen Sie int in der obigen Diskussion durch eine Dezimalstelle, und es gelten dieselben Prinzipien.

Sie können immer die integrierten TryParse-Methoden für viele Datentypen verwenden, um festzustellen, ob die betreffende Zeichenfolge übergeben wird.

Beispiel.

decimal myDec;
var Result = decimal.TryParse("123", out myDec);

Ergebnis wäre dann = True

decimal myDec;
var Result = decimal.TryParse("abc", out myDec);

Ergebnis wäre dann = Falsch

Falls Sie int.Parse oder double.Parse nicht verwenden möchten, können Sie Ihre eigenen mit so etwas rollen:

public static class Extensions
{
    public static bool IsNumeric(this string s)
    {
        foreach (char c in s)
        {
            if (!char.IsDigit(c) && c != '.')
            {
                return false;
            }
        }

        return true;
    }
}

Wenn Sie ein breiteres Spektrum von Zahlen erfassen möchten, à la PHP is_numeric , können Sie Folgendes verwenden:

// From PHP documentation for is_numeric
// (http://php.net/manual/en/function.is-numeric.php)

// Finds whether the given variable is numeric.

// Numeric strings consist of optional sign, any number of digits, optional decimal part and optional
// exponential part. Thus +0123.45e6 is a valid numeric value.

// Hexadecimal (e.g. 0xf4c3b00c), Binary (e.g. 0b10100111001), Octal (e.g. 0777) notation is allowed too but
// only without sign, decimal and exponential part.
static readonly Regex _isNumericRegex =
    new Regex(  "^(" +
                /*Hex*/ @"0x[0-9a-f]+"  + "|" +
                /*Bin*/ @"0b[01]+"      + "|" + 
                /*Oct*/ @"0[0-7]*"      + "|" +
                /*Dec*/ @"((?!0)|[-+]|(?=0+\.))(\d*\.)?\d+(e\d+)?" + 
                ")$" );
static bool IsNumeric( string value )
{
    return _isNumericRegex.IsMatch( value );
}

Gerätetest:

static void IsNumericTest()
{
    string[] l_unitTests = new string[] { 
        "123",      /* TRUE */
        "abc",      /* FALSE */
        "12.3",     /* TRUE */
        "+12.3",    /* TRUE */
        "-12.3",    /* TRUE */
        "1.23e2",   /* TRUE */
        "-1e23",    /* TRUE */
        "1.2ef",    /* FALSE */
        "0x0",      /* TRUE */
        "0xfff",    /* TRUE */
        "0xf1f",    /* TRUE */
        "0xf1g",    /* FALSE */
        "0123",     /* TRUE */
        "0999",     /* FALSE (not octal) */
        "+0999",    /* TRUE (forced decimal) */
        "0b0101",   /* TRUE */
        "0b0102"    /* FALSE */
    };

    foreach ( string l_unitTest in l_unitTests )
        Console.WriteLine( l_unitTest + " => " + IsNumeric( l_unitTest ).ToString() );

    Console.ReadKey( true );
}

Beachten Sie, dass ein numerischer Wert nicht bedeutet, dass er in einen numerischen Typ konvertiert werden kann. Beispielsweise "999999999999999999999999999999.9999999999"handelt es sich um einen perfekt gültigen numerischen Wert, der jedoch nicht in einen numerischen .NET-Typ passt (dh keinen, der in der Standardbibliothek definiert ist).

Ich weiß, dass dies ein alter Thread ist, aber keine der Antworten hat es wirklich für mich getan - entweder ineffizient oder nicht für eine einfache Wiederverwendung gekapselt. Ich wollte auch sicherstellen, dass false zurückgegeben wird, wenn die Zeichenfolge leer oder null ist. TryParse gibt in diesem Fall true zurück (eine leere Zeichenfolge verursacht beim Parsen als Zahl keinen Fehler). Also, hier ist meine String-Erweiterungsmethode:

public static class Extensions
{
    /// <summary>
    /// Returns true if string is numeric and not empty or null or whitespace.
    /// Determines if string is numeric by parsing as Double
    /// </summary>
    /// <param name="str"></param>
    /// <param name="style">Optional style - defaults to NumberStyles.Number (leading and trailing whitespace, leading and trailing sign, decimal point and thousands separator) </param>
    /// <param name="culture">Optional CultureInfo - defaults to InvariantCulture</param>
    /// <returns></returns>
    public static bool IsNumeric(this string str, NumberStyles style = NumberStyles.Number,
        CultureInfo culture = null)
    {
        double num;
        if (culture == null) culture = CultureInfo.InvariantCulture;
        return Double.TryParse(str, style, culture, out num) && !String.IsNullOrWhiteSpace(str);
    }
}

Einfach zu benutzen:

var mystring = "1234.56789";
var test = mystring.IsNumeric();

Wenn Sie andere Arten von Zahlen testen möchten, können Sie den 'Stil' angeben. Um eine Zahl mit einem Exponenten zu konvertieren, können Sie Folgendes verwenden:

var mystring = "5.2453232E6";
var test = mystring.IsNumeric(style: NumberStyles.AllowExponent);

Oder um eine mögliche Hex-Zeichenfolge zu testen, können Sie Folgendes verwenden:

var mystring = "0xF67AB2";
var test = mystring.IsNumeric(style: NumberStyles.HexNumber)

Der optionale Parameter 'Kultur' kann auf die gleiche Weise verwendet werden.

Es ist begrenzt, weil es nicht in der Lage ist, Zeichenfolgen zu konvertieren, die zu groß sind, um in einem Double enthalten zu sein. Dies ist jedoch eine begrenzte Anforderung, und ich denke, wenn Sie mit Zahlen arbeiten, die größer als diese sind, benötigen Sie wahrscheinlich eine zusätzliche spezialisierte Nummernverarbeitung funktioniert sowieso.

Mit TryParse können Sie bestimmen, ob die Zeichenfolge in eine Ganzzahl analysiert werden kann.

int i;
bool bNum = int.TryParse(str, out i);

Der Boolesche Wert sagt Ihnen, ob es funktioniert hat oder nicht.

Wenn Sie überprüfen möchten, ob eine Zeichenfolge eine Zahl ist (ich gehe davon aus, dass es sich um eine Zeichenfolge handelt, denn wenn es sich um eine Zahl handelt, wissen Sie, dass es eine ist).

• Ohne Regex und
• Verwenden Sie so viel wie möglich den Code von Microsoft

Sie könnten auch tun:

public static bool IsNumber(this string aNumber)
{
     BigInteger temp_big_int;
     var is_number = BigInteger.TryParse(aNumber, out temp_big_int);
     return is_number;
}

Dies wird sich um die üblichen Gemeinheiten kümmern:

• Minus (-) oder Plus (+) am Anfang
• enthält DezimalzeichenBigIntegers analysiert keine Zahlen mit Dezimalstellen. (Also: BigInteger.Parse("3.3")wird eine Ausnahme auslösen und TryParsefür dasselbe wird false zurückgegeben)
• keine lustigen Ziffern
• deckt Fälle ab, in denen die Anzahl größer ist als die übliche Verwendung von Double.TryParse

Sie müssen einen Verweis auf Ihre Klasse hinzufügen System.Numericsund diese using System.Numerics;an der Spitze haben (nun, der zweite ist ein Bonus, denke ich :)

Ich denke, diese Antwort wird nur zwischen all den anderen verloren gehen, aber trotzdem geht es weiter.

Ich landete in dieser Frage über Google, weil ich überprüfen wollte , ob eine stringwar numericso , dass ich nur verwenden könnte double.Parse("123")anstelle des TryParse()Verfahrens.

Warum? Weil es ärgerlich ist, eine outVariable deklarieren und das Ergebnis überprüfen zu müssen, TryParse()bevor Sie wissen, ob die Analyse fehlgeschlagen ist oder nicht. Ich möchte das verwenden ternary operator, um zu überprüfen, ob das stringist, numericalund es dann einfach im ersten ternären Ausdruck analysieren oder einen Standardwert im zweiten ternären Ausdruck angeben.

So was:

var doubleValue = IsNumeric(numberAsString) ? double.Parse(numberAsString) : 0;

Es ist nur viel sauberer als:

var doubleValue = 0;
if (double.TryParse(numberAsString, out doubleValue)) {
    //whatever you want to do with doubleValue
}

Ich habe ein paar extension methodsfür diese Fälle gemacht:

Erweiterungsmethode eins

public static bool IsParseableAs<TInput>(this string value) {
    var type = typeof(TInput);

    var tryParseMethod = type.GetMethod("TryParse", BindingFlags.Static | BindingFlags.Public, Type.DefaultBinder,
        new[] { typeof(string), type.MakeByRefType() }, null);
    if (tryParseMethod == null) return false;

    var arguments = new[] { value, Activator.CreateInstance(type) };
    return (bool) tryParseMethod.Invoke(null, arguments);
}

Beispiel:

"123".IsParseableAs<double>() ? double.Parse(sNumber) : 0;

Da IsParseableAs()versucht wird, die Zeichenfolge als geeigneten Typ zu analysieren, anstatt nur zu überprüfen, ob die Zeichenfolge "numerisch" ist, sollte sie ziemlich sicher sein. Und Sie können es sogar für nicht numerische Typen verwenden, die eine TryParse()Methode haben, wie z DateTime.

Die Methode verwendet Reflection und Sie rufen die TryParse()Methode am Ende zweimal auf, was natürlich nicht so effizient ist, aber nicht alles muss vollständig optimiert werden. Manchmal ist die Bequemlichkeit einfach wichtiger.

Diese Methode kann auch verwendet werden, um eine Liste numerischer Zeichenfolgen einfach in eine Liste doubleoder einen anderen Typ mit einem Standardwert zu analysieren, ohne Ausnahmen abfangen zu müssen:

var sNumbers = new[] {"10", "20", "30"};
var dValues = sNumbers.Select(s => s.IsParseableAs<double>() ? double.Parse(s) : 0);

Erweiterungsmethode zwei

public static TOutput ParseAs<TOutput>(this string value, TOutput defaultValue) {
    var type = typeof(TOutput);

    var tryParseMethod = type.GetMethod("TryParse", BindingFlags.Static | BindingFlags.Public, Type.DefaultBinder,
        new[] { typeof(string), type.MakeByRefType() }, null);
    if (tryParseMethod == null) return defaultValue;

    var arguments = new object[] { value, null };
    return ((bool) tryParseMethod.Invoke(null, arguments)) ? (TOutput) arguments[1] : defaultValue;
}

Mit dieser Erweiterungsmethode können Sie a stringals typeeine TryParse()Methode mit einer Methode analysieren und einen Standardwert angeben, der zurückgegeben werden soll, wenn die Konvertierung fehlschlägt.

Dies ist besser als die Verwendung des ternären Operators mit der obigen Erweiterungsmethode, da die Konvertierung nur einmal durchgeführt wird. Es wird immer noch Reflexion verwendet ...

Beispiele:

"123".ParseAs<int>(10);
"abc".ParseAs<int>(25);
"123,78".ParseAs<double>(10);
"abc".ParseAs<double>(107.4);
"2014-10-28".ParseAs<DateTime>(DateTime.MinValue);
"monday".ParseAs<DateTime>(DateTime.MinValue);

Ausgänge:

123
25
123,78
107,4
28.10.2014 00:00:00
01.01.0001 00:00:00

Wenn Sie wissen möchten, ob eine Zeichenfolge eine Zahl ist, können Sie sie jederzeit analysieren:

var numberString = "123";
int number;

int.TryParse(numberString , out number);

Beachten Sie, dass TryParsea zurückgegeben wird bool, mit dem Sie überprüfen können, ob das Parsen erfolgreich war.

Double.TryParse

bool Double.TryParse(string s, out double result)

UPDATE von Kunal Noel Antwort

stringTest.All(char.IsDigit);
// This returns true if all characters of the string are digits.

In diesem Fall bestehen jedoch leere Zeichenfolgen diesen Test. Sie können also:

if (!string.IsNullOrEmpty(stringTest) && stringTest.All(char.IsDigit)){
   // Do your logic here
}

Die beste flexible Lösung mit der in .net integrierten Funktion namens- char.IsDigit. Es funktioniert mit unbegrenzt langen Nummern. Es wird nur true zurückgegeben, wenn jedes Zeichen eine numerische Zahl ist. Ich habe es oft ohne Probleme und mit einer viel saubereren Lösung verwendet, die ich jemals gefunden habe. Ich habe eine Beispielmethode erstellt. Sie ist einsatzbereit. Zusätzlich habe ich eine Validierung für null und leere Eingaben hinzugefügt. Damit ist die Methode jetzt absolut kugelsicher

public static bool IsNumeric(string strNumber)
    {
        if (string.IsNullOrEmpty(strNumber))
        {
            return false;
        }
        else
        {
            int numberOfChar = strNumber.Count();
            if (numberOfChar > 0)
            {
                bool r = strNumber.All(char.IsDigit);
                return r;
            }
            else
            {
                return false;
            }
        }
    }

Mit c # 7 können Sie die out-Variable inline:

if(int.TryParse(str, out int v))
{
}

Verwenden Sie diese Erweiterungsmethoden, um klar zwischen einer Prüfung zu unterscheiden, ob die Zeichenfolge numerisch ist und ob die Zeichenfolge nur 0-9 Ziffern enthält

public static class ExtensionMethods
{
    /// <summary>
    /// Returns true if string could represent a valid number, including decimals and local culture symbols
    /// </summary>
    public static bool IsNumeric(this string s)
    {
        decimal d;
        return decimal.TryParse(s, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.CurrentCulture, out d);
    }

    /// <summary>
    /// Returns true only if string is wholy comprised of numerical digits
    /// </summary>
    public static bool IsNumbersOnly(this string s)
    {
        if (s == null || s == string.Empty)
            return false;

        foreach (char c in s)
        {
            if (c < '0' || c > '9') // Avoid using .IsDigit or .IsNumeric as they will return true for other characters
                return false;
        }

        return true;
    }
}

public static bool IsNumeric(this string input)
{
    int n;
    if (!string.IsNullOrEmpty(input)) //.Replace('.',null).Replace(',',null)
    {
        foreach (var i in input)
        {
            if (!int.TryParse(i.ToString(), out n))
            {
                return false;
            }

        }
        return true;
    }
    return false;
}

Hoffe das hilft

string myString = "abc";
double num;
bool isNumber = double.TryParse(myString , out num);

if isNumber 
{
//string is number
}
else
{
//string is not a number
}

Ziehen Sie in Ihrem Projekt einen Verweis auf Visual Basic ein und verwenden Sie die unten gezeigte Information.IsNumeric-Methode, um Floats und Ganzzahlen zu erfassen, im Gegensatz zu der obigen Antwort, die nur Ints abfängt.

    // Using Microsoft.VisualBasic;

    var txt = "ABCDEFG";

    if (Information.IsNumeric(txt))
        Console.WriteLine ("Numeric");

IsNumeric("12.3"); // true
IsNumeric("1"); // true
IsNumeric("abc"); // false

Probieren Sie die folgenden Zeilen aus

new Regex(@"^\d{4}").IsMatch("6")    // false
new Regex(@"^\d{4}").IsMatch("68ab") // false
new Regex(@"^\d{4}").IsMatch("1111abcdefg") ```

Alle Antworten sind nützlich. Bei der Suche nach einer Lösung mit einem numerischen Wert von 12 Stellen oder mehr (in meinem Fall) und beim Debuggen fand ich die folgende Lösung hilfreich:

double tempInt = 0;
bool result = double.TryParse("Your_12_Digit_Or_more_StringValue", out tempInt);

Die Ergebnisvariable gibt Ihnen wahr oder falsch.

Hier ist die C # -Methode. Int.TryParse-Methode (String, Int32)

//To my knowledge I did this in a simple way
static void Main(string[] args)
{
    string a, b;
    int f1, f2, x, y;
    Console.WriteLine("Enter two inputs");
    a = Convert.ToString(Console.ReadLine());
    b = Console.ReadLine();
    f1 = find(a);
    f2 = find(b);

    if (f1 == 0 && f2 == 0)
    {
        x = Convert.ToInt32(a);
        y = Convert.ToInt32(b);
        Console.WriteLine("Two inputs r number \n so that addition of these text box is= " + (x + y).ToString());
    }
    else
        Console.WriteLine("One or two inputs r string \n so that concatenation of these text box is = " + (a + b));
    Console.ReadKey();
}

static int find(string s)
{
    string s1 = "";
    int f;
    for (int i = 0; i < s.Length; i++)
       for (int j = 0; j <= 9; j++)
       {
           string c = j.ToString();
           if (c[0] == s[i])
           {
               s1 += c[0];
           }
       }

    if (s == s1)
        f = 0;
    else
        f = 1;

    return f;
}