Wie identifiziere ich, ob eine Zeichenfolge eine Zahl ist?

Diese gibt true zurück, wenn input alle zahlen. Weiß nicht, ob es besser als TryParseaber es funktioniert.

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

Wenn Sie wollen einfach nur wissen, ob es eine oder mehrere zahlen gemischt mit Buchstaben, lassen Sie die ^ + und $.

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

Edit:
Eigentlich denke ich, es ist besser als TryParse, weil Sie eine sehr lange Zeichenfolge potenziell überlauf TryParse.

InformationsquelleAutor der Antwort John M Gant

Können Sie auch verwenden:

stringTest.All(char.IsDigit);

Zurück true für alle Ziffern (nicht float) und false wenn der input-string ist jede Art von alphanumerisch.

Bitte beachten Sie: stringTest sollte keine leere Zeichenfolge sein, dies würde den test bestehen, der wird auch zahlen.

InformationsquelleAutor der Antwort Kunal Goel

Können Sie immer verwenden Sie die integrierte in der TryParse-Methoden für viele Datentypen, um zu sehen, wenn die Zeichenfolge in Frage übergeben werden.

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 = False

InformationsquelleAutor der Antwort TheTXI

Ich weiß, dies ist ein Alter thread, aber keine der Antworten richtig hat es für mich - entweder ineffizient oder nicht gekapselt für eine einfache Wiederverwendung. Ich wollte auch um sicherzustellen, dass es false zurück, wenn der string leer oder null. TryParse gibt in diesem Fall true (ein leerer string nicht zu einem Fehler beim Parsen als Zahl). So, hier ist mein string-extension-Methode:

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 bedienen:

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

Oder, wenn Sie wollen, um zu testen, andere Arten von Nummer, die Sie angeben können, 'style'.
Also, zum konvertieren einer Zahl mit einem Exponenten, den Sie verwenden könnten:

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

Oder zum testen einer potenziellen Hex-string, den Sie verwenden könnten:

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

Dem optionalen "Kultur" parameter kann verwendet werden, in viel die gleiche Weise.

Es wird begrenzt durch die nicht in der Lage zu konvertieren Zeichenfolgen, die sind zu groß, um in einem Doppelbett, aber das ist eine begrenzte Anforderung und ich denke, wenn Sie das arbeiten mit zahlen, die größer als diese, dann werden Sie wahrscheinlich benötigen zusätzliche spezialisierte Zahl-handling-Funktionen sowieso.

InformationsquelleAutor der Antwort cyberspy

Wenn Sie möchten, um zu überprüfen, ob ein string eine Zahl (ich gehe davon aus, dass es sich um einen string, da, falls es eine Zahl, duh, Sie wissen, es ist eines).

• Ohne regex und
• mithilfe von Microsoft den code soweit wie möglich

könnten Sie 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;
}

Dieser kümmert sich dann um die üblichen Gemeinheiten:

• Minus (-) oder Plus (+) am Anfang
• enthält dezimal-Trennzeichen BigIntegers nicht Parsen von zahlen mit Nachkommastellen. (Also: BigInteger.Parse("3.3") wird eine Ausnahme ausgelöst, und die TryParse für die gleichen false zurück)
• keine lustigen nicht-Ziffern
• umfasst Fälle, in denen die Zahl größer ist als die übliche Verwendung von Double.TryParse

Müssen Sie fügen Sie einen Verweis auf System.Numerics und haben
using System.Numerics; auf der Spitze Ihrer Klasse (gut, der zweite ist ein bonus, denke ich mal 🙂

InformationsquelleAutor der Antwort Noctis

Ich denke, diese Antwort wird einfach sein, verloren zwischen all den anderen, aber wie auch immer, hier geht.

Landete ich auf diese Frage über Google, weil ich wollte, um zu überprüfen, ob eine string war numeric so dass ich konnte einfach double.Parse("123") statt der TryParse() Methode.

Warum? Denn es ist ärgerlich zu haben, um zu erklären out variable und prüfen Sie das Ergebnis der TryParse() bevor Sie nun, wenn der parse failed oder nicht. Ich will das ternary operator um zu überprüfen, ob die string ist numerical und dann nur analysieren, es in den ersten ternären Ausdruck oder einen default-Wert in der zweiten ternären Ausdruck.

Wie diese:

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

Es ist einfach viel sauberer als:

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

Ich habe ein paar extension methods für diese Fälle:

Erweiterung Methode eine

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;

Weil IsParseableAs() versucht analysiert die Zeichenfolge als die geeignete Art, statt nur zu überprüfen, ob die Zeichenfolge "numeric" es sollte ziemlich sicher sein. Und Sie können es sogar für nicht-numerische Typen, der eine TryParse() Methode, wie DateTime.

Verwendet die Methode der Reflexion und Sie am Ende aufrufen der TryParse() - Methode zweimal, was natürlich nicht so effizient, aber nicht alles vollständig optimiert ist, manchmal ist die Bequemlichkeit einfach wichtiger.

Diese Methode kann auch verwendet werden, um leicht zu analysieren, eine Liste der numerischen strings in eine Liste von double oder eine andere Art mit einem default-Wert, ohne alle Ausnahmen abzufangen:

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

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

Diese Erweiterung-Methode können Sie analysieren eine string wie jeder type hat eine TryParse() Methode und ermöglicht es Ihnen zudem, geben Sie einen Standardwert zurück, falls die Konvertierung fehlschlägt.

Dies ist besser als mit den ternären operator mit der Erweiterung Methode von oben, wie es funktioniert nur die Konvertierung noch, immer noch verwendet reflektion, obwohl...

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

InformationsquelleAutor der Antwort Hein Andre Grønnestad

Wenn du wissen willst, ob ein string eine Zahl ist, können Sie immer versuchen analysiert:

var numberString = "123";
int number;

int.TryParse(numberString , out number);

Beachten Sie, dass TryParse gibt eine booldie Sie verwenden können, um zu prüfen, ob das Parsen erfolgreich war.

InformationsquelleAutor der Antwort Gabriel Florit

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
}

InformationsquelleAutor der Antwort Arun

Ziehen Sie in einen Verweis auf Visual Basic in Ihrem Projekt und verwenden Ihre Informationen.IsNumeric Methode wie unten gezeigt, und in der Lage sein zu erfassen, schwebt ebenso wie die ganzen zahlen im Gegensatz zu der Antwort oben, die nur Fänge mit int-Werten.

    //Using Microsoft.VisualBasic;

    var txt = "ABCDEFG";

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

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

InformationsquelleAutor der Antwort ΩmegaMan

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

InformationsquelleAutor der Antwort Vino