Identifier si une chaîne est un nombre


732

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?


79
à partir de leurs exemples, vous pouvez voir qu'ils signifiaient si la chaîne entière représente un nombre.
Lucas

47
return str.All (Char.IsDigit);
Mohsen

13
str.All (Char.IsDigit) déclarera "3.14" faux ainsi que "-2" et "3E14". Sans parler de: "0x10"
Harald Coppoolse

4
Cela dépend du type de numéro que vous essayez de vérifier. Pour les nombres entiers sans séparateur (c'est-à-dire les chaînes de chiffres décimaux), cette vérification fonctionne et est la même que la réponse acceptée et celle impliquée dans OP.
Alex Mazzariol

1
@Lucas merci pour votre commentaire, vous n'avez AUCUNE idée depuis combien de temps j'essaie d'analyser une chaîne double comme un int et je me demande pourquoi elle échouait ...
Novastorm

Réponses:


1160
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!


126
Cependant, j'utiliserais double.TryParse, car nous voulons savoir s'il représente un nombre.
John Gietzen

5
La fonction retournera vrai si je passe la chaîne comme "-123" ou "+123". Je comprends que l'entier a des valeurs positives et négatives. Mais si cette chaîne provient de la zone de texte entrée par l'utilisateur, elle doit retourner false.
user2323308

9
C'est une bonne solution, jusqu'à ce qu'un utilisateur entre une valeur au-delà de -2.147.483.648 à 2.147.483.647, puis cela échoue en silence
BlackTigerX

essayez d'analyser 0,60 (c'est une virgule!) c'est un nombre invalide mais sera analysé comme 60!
Paul Zahra

2
Je préfère avoir une méthode d'extension pour cette vérification: public static bool IsNumeric(this string text) { double _out; return double.TryParse(text, out _out); }
Hamid Naeemi

350

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.


2
La construction de l'expression rationnelle une fois pour toutes serait cependant beaucoup plus efficace.
Clément le

2
@CFP +1 ... RegEx sont toujours meilleures que les fonctions habituelles, le cas échéant!
MAXE

19
@MAXE: Je ne serais pas d'accord. Les vérifications des expressions régulières sont assez lentes, il existe donc souvent de meilleures solutions si les performances sont prises en compte.
Michal B.

7
edit: vous pouvez ajouter RegexOptions.Compiledcomme paramètre si vous en exécutez des milliers pour une augmentation possible de la vitesseRegex.IsMatch(x.BinNumber, @"^\d+$", RegexOptions.Compiled)
Simon_Weaver

9
échouera également sur les négatifs et les choses avec.
Noctis

199

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.


20
C'est très cool. Une chose à savoir cependant: une chaîne vide passera ce test comme étant numérique.
dan-gph

2
@ dan-gph: Je suis content, vous l'aimez. Oui tu as raison. J'ai mis à jour la note ci-dessus. Merci!
Kunal Goel

1
cela ne fonctionne pas non plus pour les décimales. Le bon test sera stringTest.All (l => char.IsDigit (l) || '.' == l || '-' == l);
Salman Hasrat Khan

Merci pour votre entrée Salman, Pour vérifier spécifiquement la décimale d'une chaîne, vous pouvez opter pour - if (Decimal.TryParse (stringTest2, out value)) {/ * Yes, Decimal /} else {/ No, Not a Decimal * / }
Kunal Goel

6
Salman, ce n'est pas si simple - cela passerait ..--..--comme un nombre valide. Pas du tout.
Flynn1179

133

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

texte alternatif
(source: aspalliance.com )

texte alternatif
(source: aspalliance.com )


80
référencer Microsoft.VisualBasic.dll à partir de l'application C #? eww: P
Lucas

Je n'ai aucun problème à utiliser "IsNumeric" ça marche bien. Vous pouvez également voir qu'il y a peu de différence d'efficacité entre TryParse et IsNumeric. N'oubliez pas que TryParse est nouveau dans la version 2.0 et avant cela, il était préférable d'utiliser IsNumeric que toute autre stratégie.
Nelson Miranda,

10
Eh bien, IsNumeric () de VB.NET utilise en interne double.TryParse (), après un certain nombre de girations nécessaires (entre autres) pour la compatibilité VB6. Si vous n'avez pas besoin de compatibilité, double.TryParse () est tout aussi simple à utiliser et vous évite de gaspiller de la mémoire en chargeant Microsoft.VisualBasic.dll dans votre processus.
Euro Micelli

4
Remarque rapide: l'utilisation d'une expression régulière sera beaucoup plus rapide si vous parvenez à faire construire la machine à états finis sous-jacente une fois pour toutes. Généralement, la construction de la machine d'état prend O (2 ^ n) où n est la longueur de l'expression rationnelle, tandis que la lecture est O (k) où k est la longueur de la chaîne recherchée. Donc, la reconstruction de l'expression régulière à chaque fois introduit un biais.
Clément

2
@Lucas En fait, il y a des trucs vraiment sympas là-dedans, comme un analyseur csv complet. Aucune raison de ne pas l'utiliser s'il existe là-dedans.
Nyerguds

32

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.


Pourquoi TryParse est-il meilleur que de comparer tous les caractères avec des caractères entiers?
jimjim

25

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


Je pense que je l'ai peut-être fait plus dans la syntaxe de style VB que C #, mais les mêmes règles s'appliquent.
TheTXI

22

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

7
Et s'ils ne signifiaient que des entiers? Qu'en est-il des paramètres régionaux où "." est le séparateur de groupe, pas la virgule (par exemple pt-Br)? qu'en est-il des nombres négatifs? séparateurs de groupes (virgules en anglais)? symboles monétaires? TryParse () peut gérer tout cela selon les besoins à l'aide de NumberStyles et IFormatProvider.
Lucas

Ooh ouais, j'aime mieux la version All. Je n'ai jamais utilisé cette méthode d'extension, bon appel. Bien qu'il devrait s'agir de s.ToCharArray (). All (..). Quant à votre deuxième point, je vous entends, c'est pourquoi j'ai préfacé si vous ne voulez pas utiliser int.Parse .... (qui je suppose a plus de frais généraux ...)
BFree

11
1.3.3.8.5 n'est pas vraiment un nombre, alors que 1.23E5 l'est.
Clément

4
la logique est défectueuse. -1
Russel Yang

1
@Lucas Je suis d'accord que TryParse gère plus, mais parfois ce n'est pas nécessaire. J'ai juste besoin de valider mes cases de numéro de carte de crédit (qui ne peuvent avoir que des chiffres). Cette solution est presque certainement plus rapide que d'essayer l'analyse.
Millie Smith,

14

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


N'essayant pas d'être un alec intelligent ici, mais cela semble échouer pour la chaîne "0". Mon Regex est inexistant. Y a-t-il un simple ajustement pour cela? J'obtiens "0" et éventuellement "0.0" et même "-0.0" comme chiffres valides possibles.
Steve Hibbert

@SteveHibbert - Tout le monde sait que "0" n'est pas un nombre! Sérieusement cependant ... ajusté l'expression régulière pour qu'elle corresponde à 0.
JDB se souvient encore de Monica

Hmmm, est-ce moi ou "0" n'est-il toujours pas reconnu comme numérique?
Steve Hibbert

1
Étant paresseux et ignorant les expressions rationnelles, j'ai coupé le code ci-dessus, qui semble inclure le changement de type "0.0". J'ai exécuté un test pour vérifier qu'une chaîne "0" exécutait .IsNumeric (), et cela renvoyait false. Je pense que le test octal retournera vrai pour tout ce qui a deux caractères numériques où le premier est zéro (et le second est zéro à sept), mais retournera faux pour juste un gros zéro solitaire seul. Si vous testez "0", avec le code ci-dessus, obtenez-vous faux? Toutes mes excuses, si je connaissais plus d'expressions régulières, je serais en mesure de donner de meilleurs commentaires. Doit lire.
Steve Hibbert

1
! Doh! Relisez simplement votre commentaire ci-dessus, j'avais raté l'astérisque supplémentaire, je n'ai mis à jour que la ligne décimale. Avec cela en place, vous avez raison, "0" IsNumeric. Toutes mes excuses pour les faffings, et merci beaucoup pour la mise à jour, j'espère que cela aidera les autres aussi. Infiniment reconnaissant.
Steve Hibbert

14

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.


2
Fonctionne très bien, sauf que Double.TryParse ne prend pas en charge NumberStyles.HexNumber. Voir MSDN Double.TryParse. Une raison pour laquelle vous essayez TryParse avant de vérifier IsNullOrWhiteSpace? TryParse renvoie false si IsNullOrWhiteSpace ne le fait pas?
Harald Coppoolse

10

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.


9

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


8

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

4
Je pense que vous avez peut-être inventé l'une des approches les plus inefficaces que j'ai jamais vues. Non seulement vous analysez la chaîne deux fois (dans le cas où elle est analysable), vous appelez également les fonctions de réflexion plusieurs fois pour le faire. Et, à la fin, vous n'enregistrez même aucune touche en utilisant la méthode d'extension.
JDB se souvient encore de Monica

Merci de répéter ce que j'ai écrit moi-même dans l'avant-dernier paragraphe. De plus, si vous prenez mon dernier exemple en compte, vous enregistrez définitivement les frappes en utilisant cette méthode d'extension. Cette réponse ne prétend pas être une sorte de solution magique à un problème, c'est simplement un exemple de code. Utilisez-le ou ne l'utilisez pas. Je pense que c'est pratique lorsqu'il est bien utilisé. Et cela inclut des exemples de méthodes d'extension et de réflexion, peut-être que quelqu'un peut en tirer des leçons.
Hein Andre Grønnestad

5
As-tu essayé var x = double.TryParse("2.2", new double()) ? double.Parse("2.2") : 0.0;?
JDB se souvient encore de Monica

2
Oui, et ça ne marche pas. Argument 2 must be passed with the 'out' keywordet si vous spécifiez outaussi bien que newvous obtenez A ref or out argument must be an assignable variable.
Hein Andre Grønnestad

1
Les performances TryParse sont meilleures que toutes celles présentées ici. Résultats: TryParse 8 Regex 20 PHP IsNumeric 30 Réflexions TryParse 31 Code de test dotnetfiddle.net/x8GjAF
prampe

7

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.



4

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
}

4

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

2

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

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

2

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

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

1

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
}

0

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

Un problème potentiel avec cette approche est IsNumericune analyse de caractère de la chaîne. Donc, un nombre comme 9999999999999999999999999999999999999999999999999999999999.99999999999s'enregistrera comme True, même s'il n'y a aucun moyen de représenter ce nombre en utilisant un type numérique standard.
JDB se souvient encore de Monica

0

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

0

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.



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

1
Quatre downvotes, mais personne n'a dit pourquoi? Je suppose que c'est parce que TryParse / Parse serait une meilleure option, mais tout le monde ici ne le saura pas.
njplumridge

2
Vous avez rendu les choses si compliquées que même le programmeur C dirait "ça alors, il doit y avoir un moyen plus simple d'écrire ça"
Ch3shire

1. Il n'y a aucune raison de lire DEUX numéros à partir de la console et de les ajouter. La provenance de la chaîne n'a de toute façon aucune importance, il n'y a donc aucune raison de lire quoi que ce soit sur la console.
Algoman

2. La variable pour f n'est pas nécessaire, vous pouvez retourner directement 0 ou 1 - si vous voulez un seul retour, vous pouvez utiliser l'opérateur ternaire pour cela. int est également le mauvais type de retour pour find, il devrait être booléen et vous pouvez retourner s == s1
Algoman

3. vous copiez les chiffres de s à s1, puis comparez s à s1. C'est beaucoup plus lent que nécessaire. Aussi pourquoi continuez-vous la boucle interne même si c [0] == s [i] s'est produit? Vous attendez-vous à ce que s [i] soit également égal à d'autres chiffres?
Algoman
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.