Question Comment identifier si une chaîne est un nombre?

Cela retournera vrai si input est tous les nombres. Je ne sais pas si c'est mieux que TryParse, mais ça va marcher.

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

Si vous voulez simplement savoir si un ou plusieurs nombres sont mélangés avec des caractères, laissez le ^  + et $.

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

Modifier: En fait je pense que c'est mieux que TryParse car une très longue chaîne pourrait potentiellement déborder de TryParse.

Vous pouvez aussi utiliser:

stringTest.All(char.IsDigit);

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

Notez s'il vous plaît: stringTest ne devrait pas être une chaîne vide car cela passerait le test d'ê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 L'analyse comparative est des options numériques

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

alt text 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 (entier):

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

La méthode TryParse essayera de convertir la chaîne en nombre (entier) et si elle réussit, elle retournera true et placera le nombre correspondant dans myInt. Si ce n'est pas le cas, cela renvoie false.

Solutions utilisant le int.Parse(someString) alternative montré dans d'autres réponses fonctionne, mais il est beaucoup plus lent, car lancer des exceptions est très coûteux. TryParse(...) a été ajouté à la langue C # dans la version 2, et jusque-là, vous n'aviez pas le choix. Maintenant vous faites: vous devriez donc éviter Parse() alternative.

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

Vous pouvez toujours utiliser les méthodes TryParse intégrées 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);

Le résultat serait alors = True

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

Le résultat serait alors = Faux

Dans le cas où vous ne voulez pas utiliser int.Parse ou double.Parse, vous pouvez rouler le vôtre 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 fil, mais aucune des réponses ne l'a vraiment fait pour moi - soit inefficace, ou pas encapsulé pour une réutilisation facile. Je voulais aussi m'assurer qu'il renvoyait false si la chaîne était vide ou nulle. TryParse renvoie true dans ce cas (une chaîne vide ne provoque 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 nombres, vous pouvez spécifier le 'style'. Ainsi, 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é par le fait de ne pas pouvoir convertir les 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 des nombres plus grands, vous aurez probablement besoin d'un traitement spécialisé fonctions de toute façon.

Si vous voulez attraper un plus grand nombre de nombres, à la PHP est_numérique, 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 );
}

Test de l'unité:

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 le fait qu'une valeur soit numérique ne signifie pas qu'elle peut être convertie en un type numérique. Par exemple, "999999999999999999999999999999.9999999999" est une valeur numérique valide, mais elle ne rentre pas dans un type numérique .NET (pas 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, duh, vous savez que c'est un).

• Sans regex et
• en utilisant le code de Microsoft autant que possible

vous pourriez aussi 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 méchants habituels:

• Moins (-) ou Plus (+) au début
• contient un caractère décimal BigIntegers n'analysera pas les nombres avec des points décimaux. (Alors: BigInteger.Parse("3.3") va jeter une exception, et TryParse pour la même chose retournera faux)
• pas de non-chiffres drôles
• couvre les cas où le nombre est plus grand que l'utilisation habituelle de Double.TryParse

Vous devrez ajouter une référence à System.Numerics et avoir using System.Numerics; en plus de votre classe (enfin, la seconde est un bonus je suppose :)

Vous pouvez utiliser TryParse pour déterminer si la chaîne peut être analysée en entier.

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

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