Comment puis-je déterminer si une chaîne est un nombre?

cela retournera vrai si input est tous les nombres. Ne sais pas si c'est mieux que TryParse , mais il faudra travailler.

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

si vous voulez juste savoir si elle a un ou plusieurs nombres mélangés avec des caractères, laissez de côté les ^ + et $ .

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

Edit: En fait, je pense que C'est mieux que TryParse parce qu'une corde très longue pourrait potentiellement déborder TryParse.

vous pouvez également utiliser:

stringTest.All(char.IsDigit);

il retournera true pour tous les chiffres numériques (pas float ) et false si la chaîne d'entrée est une sorte d'alphanumérique.

prendre note : stringTest ne doit pas être une chaîne vide, ce qui permettrait de passer le test de l'être numérique.

j'ai utilisé cette fonction plusieurs fois:

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

mais vous pouvez aussi utiliser;""

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

De Benchmarking IsNumeric Options

alt texte http://aspalliance.com/images/articleimages/80/Figure1.gif

alt texte http://aspalliance.com/images/articleimages/80/Figure2.gif

C'est probablement la meilleure option en C#.

si vous voulez savoir si la chaîne contient un nombre entier:

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

la méthode TryParse essaiera de convertir la chaîne en un nombre (entier) et si elle réussit, elle retournera true et placera le nombre correspondant dans myInt. S'il ne peut pas, il retourne false.

des Solutions à l'aide de la int.Parse(someString) alternative à d'autres réponses œuvres, mais il est beaucoup plus lent parce que jeter des exceptions est très cher. TryParse(...) a été ajouté au langage C# dans la version 2, et jusque là vous n'aviez pas le choix. Maintenant vous le faites: vous devez donc éviter l'alternative Parse() .

si vous voulez accepter des nombres décimaux, la classe décimale a aussi une méthode .TryParse(...) . Remplacer int par décimal dans la discussion ci-dessus, et les mêmes principes s'appliquent.

vous pouvez toujours utiliser les méthodes construites dans TryParse pour de nombreux types de données pour voir si la chaîne en question passera.

exemple.

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

Result then = True

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

Result then = False

dans le cas où vous ne voulez pas utiliser int.Parse ou double.Analyser, vous pouvez rouler votre propre avec quelque chose comme ceci:

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

je sais que c'est un vieux thread, mais aucune des réponses vraiment fait pour moi - soit inefficace, ou non encapsulé pour les réutiliser facilement. Je voulais aussi m'assurer qu'il retournait false si la chaîne était vide ou nulle. TryParse retourne true dans ce cas (une chaîne vide ne cause pas d'erreur lors de l'analyse en tant que nombre). Donc, voici ma méthode d'extension de chaîne:

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

Simple à utiliser:

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

Ou, si vous voulez tester d'autres types de de numéro, vous pouvez préciser le "style". Donc, pour convertir un nombre avec un Exposant, vous pouvez utiliser:

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

ou pour tester une chaîne hexadécimale potentielle, vous pouvez utiliser:

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

le paramètre facultatif "culture" peut être utilisé de la même manière.

il est limité en n'étant pas capable de convertir des chaînes qui sont trop grandes pour être contenues dans un double, mais c'est une exigence limitée et je pense que si vous travaillez avec les nombres plus grands que cela, alors vous aurez probablement besoin de plus de fonctions spécialisées de manipulation de nombre de toute façon.

si vous voulez attraper un plus large spectre de nombres, à la PHP's is_numeric , vous pouvez utiliser ce qui suit:

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

Essai Unitaire:

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

gardez à l'esprit que ce n'est pas parce qu'une valeur est numérique qu'elle peut être convertie en un type numérique. Par exemple, "999999999999999999999999999999.9999999999" est une valeur numérique valide de perfeclty, mais elle ne rentre pas dans un type numérique .NET (pas un défini dans la bibliothèque standard, c'est-à-dire).

Si vous voulez vérifier si une chaîne est un nombre (je suppose que c'est une chaîne, car si c'est un nombre, euh, vous savez, c'est une).

• sans regex et
• utilisant autant que possible le code de Microsoft

, vous pouvez aussi le faire:

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

cela prendra soin des nasties habituelles:

• moins (-) ou Plus (+) au début
• contient "caractère décimal 1519230920" BigIntegers de ne pas analyser des nombres avec décimales. (Donc: BigInteger.Parse("3.3") va lever une exception, et TryParse pour le même renvoie false)
• pas drôle non chiffres
• couvre les cas où le nombre est supérieur à l'utilisation habituelle de Double.TryParse

vous devez ajouter une référence à System.Numerics et avoir using System.Numerics; en haut de votre classe (eh bien, le second est un bonus, je suppose :)

vous pouvez utiliser TryParse pour déterminer si la chaîne peut être divisée en un entier.

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

le booléen vous dira si cela a fonctionné ou non.

je suppose que cette réponse sera perdue entre toutes les autres, mais de toute façon, voilà.

j'ai fini sur cette question via Google parce que je voulais vérifier si un string était numeric afin que je puisse juste utiliser double.Parse("123") au lieu de la méthode TryParse() .

pourquoi? Parce qu'il est ennuyeux de devoir déclarer une variable out et vérifier le résultat de TryParse() avant vous maintenant si l'analyse a échoué ou non. Je veux utiliser le ternary operator pour vérifier si le string est numerical et puis juste l'analyser dans la première expression ternaire ou fournir une valeur par défaut dans la deuxième expression ternaire.

comme ceci:

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

C'est juste beaucoup plus propre que:

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

j'ai fait un couple extension methods pour ces cas:

Extension première méthode

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

exemple:

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

parce que IsParseableAs() essaie d'analyser la chaîne comme le type approprié au lieu de simplement vérifier si la chaîne est" numérique " il devrait être assez sûr. Et vous pouvez même l'utiliser pour les types non numériques qui ont une méthode TryParse() , comme DateTime .

la méthode utilise la réflexion et vous finissez par appeler la méthode TryParse() deux fois ce qui, bien sûr, n'est pas aussi efficace, mais tout ne doit pas être entièrement optimisé, parfois la commodité est juste plus important.

cette méthode peut également être utilisée pour analyser facilement une liste de chaînes numériques dans une liste de double ou un autre type avec une valeur par défaut sans avoir à attraper des exceptions:

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

de la méthode d'Extension de deux

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

cette méthode d'extension vous permet d'analyser un string comme n'importe quel type qui a une méthode TryParse() et il vous permet également de spécifier une valeur par défaut pour retourner si la conversion échoue.

c'est mieux que d'utiliser l'opérateur ternaire avec la méthode d'extension ci-dessus car il ne fait la conversion qu'une fois, utilise encore la réflexion cependant...

exemples:

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

sorties:

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

Double.TryParse

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

Si vous voulez savoir si une chaîne est un nombre, vous pouvez toujours essayer de l'analyser:

var numberString = "123";
int number;

int.TryParse(numberString , out number);

notez que TryParse renvoie un bool , que vous pouvez utiliser pour vérifier si votre parsing a réussi.

avec c# 7 it vous pouvez inline la variable out:

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

utiliser ces méthodes d'extension pour distinguer clairement entre un contrôle si la chaîne est numérique et si la chaîne seulement contient 0-9 chiffres

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

Espérons que cette aide

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

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

Voici la méthode C#. Int.Méthode TryParse (String, Int32)

tirez une référence à Visual Basic dans votre projet et utilisez ses informations.Méthode isnumérique telle que montrée ci-dessous et être en mesure de capturer des flotteurs ainsi que des entiers contrairement à la réponse ci-dessus qui ne capture que les ints.

    // Using Microsoft.VisualBasic;

    var txt = "ABCDEFG";

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

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

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