Identifier si une chaîne est un nombre

Si j'ai ces cordes:

1. "abc" = false

2. "123" = true

3. "ab2" = false

Existe-t-il une commande, comme IsNumeric()ou autre chose, qui peut identifier si une chaîne est un nombre valide?

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

Mise à jour à partir de C # 7:

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

ou si vous n'avez pas besoin du numéro , vous pouvez jeter le paramètre out

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

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

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

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

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

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

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

Vous pouvez aussi utiliser:

stringTest.All(char.IsDigit);

Il retournera truepour tous les chiffres numériques (pas float) et falsesi la chaîne d'entrée est de n'importe quelle sorte alphanumérique.

Veuillez noter : stringTestne doit 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 également utiliser;

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

À partir de l' analyse comparative des options isNumeric

_{(source: aspalliance.com )}

_{(source: aspalliance.com )}

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 tentera de convertir la chaîne en un nombre (entier) et si elle réussit, elle renverra true et placera le nombre correspondant dans myInt. Si ce n'est pas le cas, il renvoie faux.

Les solutions utilisant l' int.Parse(someString)alternative indiquée dans d'autres réponses fonctionnent, mais elles sont beaucoup plus lentes car lever des exceptions coûte 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' Parse()alternative.

Si vous souhaitez accepter des nombres décimaux, la classe décimale a également une .TryParse(...)méthode. Remplacez int par decimal 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 = Vrai

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

Le résultat serait alors = Faux

Dans le cas où vous ne souhaitez pas utiliser int.Parse ou double.Parse, vous pouvez lancer 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;
    }
}

Si vous voulez capturer un plus large éventail de nombres, à la is_numeric de PHP , 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 type numérique. Par exemple, "999999999999999999999999999999.9999999999"est une valeur numérique parfaitement valide, mais elle ne rentre pas dans un type numérique .NET (pas celui défini dans la bibliothèque standard, c'est-à-dire).

Je sais que c'est un vieux fil, mais aucune des réponses ne l'a vraiment fait pour moi - soit inefficace, soit non encapsulé pour une réutilisation facile. Je voulais également m'assurer qu'il retournait faux 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). Alors, 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 souhaitez tester d'autres types de numéros, 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 optionnel «culture» peut être utilisé de la même manière.

Il est limité de ne pas pouvoir convertir des chaînes 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 que cela, alors vous aurez probablement besoin d'une gestion de nombre spécialisée supplémentaire fonctionne de toute façon.

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

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

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

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

• Sans regex et
• utiliser 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écimalBigIntegers n'analysera pas les nombres avec des décimales. (Donc: BigInteger.Parse("3.3")va lever une exception, et TryParsepour le même retourne faux)
• pas de drôles de non-chiffres
• couvre les cas où le nombre est supérieur à l'utilisation habituelle de Double.TryParse

Vous devrez ajouter une référence à System.Numericset avoir using System.Numerics;au-dessus de votre classe (enfin, le second est un bonus je suppose :)

Je suppose que cette réponse sera simplement perdue entre toutes les autres, mais de toute façon, c'est parti.

Je me suis retrouvé sur cette question via Google parce que je voulais vérifier si stringc'était numericpour que je puisse simplement utiliser à la double.Parse("123")place duTryParse() méthode.

Pourquoi? Parce que c'est ennuyeux de devoir déclarer une outvariable et de vérifier le résultat TryParse()avant de savoir si l'analyse a échoué ou non. Je veux utiliser ternary operatorpour vérifier si le stringestnumerical , puis l'analyser dans la première expression ternaire ou fournir une valeur par défaut dans la deuxième expression ternaire.

Comme ça:

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 methodspour ces cas:

Première méthode d'extension

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 qu'il IsParseableAs()essaie d'analyser la chaîne en tant que type approprié au lieu de simplement vérifier si la chaîne est "numérique", cela devrait être assez sûr. Et vous pouvez même l'utiliser pour des types non numériques qui ont une TryParse()méthode, commeDateTime .

La méthode utilise la réflexion et vous finissez par appeler la TryParse()méthode 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 importante.

Cette méthode peut également être utilisée pour analyser facilement une liste de chaînes numériques dans une liste de doubleou un autre type avec une valeur par défaut sans avoir à intercepter d'exceptions:

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

Méthode d'extension 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 stringcomme tout typequi a unTryParse() méthode et vous permet également de spécifier une valeur par défaut à renvoyer 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 seule fois. Il utilise toujours la réflexion ...

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

Les sorties:

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

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 TryParserenvoie un bool, que vous pouvez utiliser pour vérifier si votre analyse a réussi.

Double.TryParse

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

MISE À JOUR de la réponse de Kunal Noel

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

Mais, dans ce cas, nous avons que les chaînes vides passeront ce test, vous pouvez donc:

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

La meilleure solution flexible avec la fonction intégrée .net appelée- char.IsDigit. Il fonctionne avec des numéros longs illimités. Il ne retournera vrai que si chaque caractère est un nombre numérique. Je l'ai utilisé beaucoup de fois sans problème et avec une solution beaucoup plus propre que j'ai jamais trouvée. J'ai fait un exemple de méthode, elle est prête à l'emploi. De plus, j'ai ajouté une validation pour les entrées nulles et vides. 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;
            }
        }
    }

Avec c # 7, vous pouvez incorporer la variable out:

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

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

J'espère que cela t'aides

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

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

Tirez une référence à Visual Basic dans votre projet et utilisez sa méthode Information.IsNumeric telle que celle illustrée ci-dessous et soyez capable de capturer des flottants ainsi que des entiers contrairement à la réponse ci-dessus qui ne capture que des ints.

    // Using Microsoft.VisualBasic;

    var txt = "ABCDEFG";

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

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

Essayez les reges ci-dessous

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

Toutes les réponses sont utiles. Mais lors de la recherche d'une solution où la valeur numérique est de 12 chiffres ou plus (dans mon cas), puis lors du débogage, j'ai trouvé la solution suivante utile:

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

La variable de résultat vous donnera vrai ou faux.

Voici la méthode C #. Méthode Int.TryParse (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;
}