Identifier si une chaîne est un nombre

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

Mise à jour de C# 7:

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

La var s peuvent être remplacés par leurs types respectifs!

Vous pouvez également utiliser:

stringTest.All(char.IsDigit);

Il sera de retour true pour tous les Chiffres (pas float) et false si la chaîne d'entrée est toute sorte de alphanumériques.

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

C'est probablement la meilleure option en C#.

Si vous voulez savoir si la chaîne contient un nombre entier (integer):

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

La méthode TryParse va essayer de convertir la chaîne en nombre (entier) et si elle réussit, elle sera de retour véritable lieu et le numéro correspondant dans myInt. Si il ne peut pas, elle retourne false.

Solutions à l'aide de la int.Parse(someString) alternative à d'autres réponses œuvres, mais il est beaucoup plus lent en raison de lever des exceptions est très cher. TryParse(...) a été ajouté le langage C# dans la version 2, et jusqu'alors, vous n'avez pas le choix. Maintenant vous le savez: il faut donc éviter de le Parse() alternative.

Si vous souhaitez accepter les nombres décimaux, les décimales classe possède également une .TryParse(...) méthode. Remplacer int avec décimale dans la discussion ci-dessus, et les mêmes principes s'appliquent.

Dans le cas où vous ne souhaitez pas utiliser int.Analyser 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;
    }
}

Si vous voulez attraper un plus large éventail de numéros, à la de PHP is_numeric, vous pouvez utiliser les éléments suivants:

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

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

Garder à l'esprit que juste parce que une valeur numérique ne signifie pas qu'il peut être converti en un type numérique. Par exemple, "999999999999999999999999999999.9999999999" est un perfeclty valeur numérique valide, mais il ne rentre pas dans une .NET numérique de type (pas celle qui est définie dans la bibliothèque standard, qui est).

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
• à l'aide de Microsoft du code autant que possible

vous pouvez 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 va prendre soin de l'habituel méchants:

• Moins (-) ou Plus (+) dans le début
• contient le caractère décimal BigIntegers de ne pas analyser des nombres avec décimales. (Donc: BigInteger.Parse("3.3") va lever une exception, et TryParse pour la même renvoie false)
• pas drôle non chiffres
• couvre les cas où le nombre est plus grand que l'usage habituel de Double.TryParse

Vous devez ajouter une référence à System.Numerics et ont
using System.Numerics; sur le dessus de votre classe (eh bien, le second est un bonus, je suppose 🙂

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

Noter que TryParse renvoie une bool, que vous pouvez utiliser pour vérifier si votre analyse réussi.

Mise à JOUR de Kunal Noel Réponse

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

Mais, pour ce cas, nous avons que les cordes à vide va passer ce test, vous pouvez donc:

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

L'utilisation de ces méthodes d'extension pour distinguer clairement entre une vérifier si la chaîne est numérique et si la chaîne seulement contient de 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;
    }
}

La meilleure solution souple avec .net fonction intégrée appelée- char.IsDigit. Il fonctionne avec un nombre illimité de numéros longs. Il ne retournera vrai si chaque caractère est un nombre numérique. Je l'ai utilisé beaucoup de fois sans aucun problème et beaucoup plus facilement solution plus propre que j'ai jamais trouvé. J'ai fait un exemple de la méthode.Son prêt à l'emploi. En outre, j'ai ajouté de validation pour les nuls et vides d'entrée. Donc la méthode est maintenant totalement à l'épreuve des balles

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

Tirer dans la référence Visual Basic dans votre projet et l'utilisation de ses Informations.IsNumeric méthode comme indiqué ci-dessous et être en mesure de capturer des chars ainsi que des entiers, à la différence de la réponse au-dessus de laquelle seulement les captures ints.

    //Using Microsoft.VisualBasic;

    var txt = "ABCDEFG";

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

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

Toutes les Réponses sont Utiles. Mais alors que la recherche d'une solution dans laquelle la valeur Numérique est de 12 chiffres ou plus (dans mon cas), puis pendant le débogage, j'ai trouvé la solution suivante utiles :

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

Ème variable résultat va vous donner le vrai ou le faux.

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