Identificare se una stringa è un numero

Se ho queste stringhe:

1. "abc" = false

2. "123" = true

3. "ab2" = false

Esiste un comando, come IsNumeric()o qualcos'altro, che può identificare se una stringa è un numero valido?

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

Aggiornamento a partire da C # 7:

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

o se non hai bisogno del numero puoi scartare il parametro out

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

I var possono essere sostituiti dai rispettivi tipi!

Questo restituirà vero se inputsono tutti i numeri. Non so se è meglio di TryParse, ma funzionerà.

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

Se vuoi solo sapere se ha uno o più numeri mescolati con i caratteri, lascia ^ +e $.

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

Modifica: in realtà penso che sia meglio di TryParse perché una stringa molto lunga potrebbe potenzialmente traboccare TryParse.

Puoi anche usare:

stringTest.All(char.IsDigit);

Restituirà trueper tutte le cifre numeriche (non float) e falsese la stringa di input è qualsiasi tipo di alfanumerico.

Nota : stringTestnon deve essere una stringa vuota poiché supererebbe il test di essere numerico.

Ho usato questa funzione più volte:

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

Ma puoi anche usare;

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

Dal benchmarking delle opzioni IsNumeric

_{(fonte: aspalliance.com )}

_{(fonte: aspalliance.com )}

Questa è probabilmente l'opzione migliore in C #.

Se vuoi sapere se la stringa contiene un numero intero (intero):

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

Il metodo TryParse proverà a convertire la stringa in un numero (intero) e, se riesce, restituirà true e inserirà il numero corrispondente in myInt. In caso contrario, restituisce false.

Le soluzioni che utilizzano l' int.Parse(someString)alternativa mostrata in altre risposte funzionano, ma è molto più lenta perché generare eccezioni è molto costoso. TryParse(...)è stato aggiunto al linguaggio C # nella versione 2 e fino ad allora non avevi scelta. Ora lo fai: dovresti quindi evitare l' Parse()alternativa.

Se si desidera accettare numeri decimali, anche la classe decimale ha un .TryParse(...)metodo. Sostituisci int con decimale nella discussione precedente e si applicano gli stessi principi.

Puoi sempre utilizzare i metodi TryParse integrati per molti tipi di dati per vedere se la stringa in questione passerà.

Esempio.

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

Il risultato sarebbe quindi = Vero

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

Il risultato sarebbe quindi = Falso

Nel caso in cui non si desideri utilizzare int.Parse o double.Parse, è possibile eseguire il rollback con qualcosa del genere:

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

Se vuoi catturare uno spettro più ampio di numeri, come is_numeric di PHP , puoi usare quanto segue:

// 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 unitario:

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

Tieni presente che solo perché un valore è numerico non significa che può essere convertito in un tipo numerico. Ad esempio, "999999999999999999999999999999.9999999999"è un valore numerico valido perfettamente, ma non si adatta a un tipo numerico .NET (non uno definito nella libreria standard, cioè).

So che questo è un vecchio thread, ma nessuna delle risposte lo ha fatto davvero per me - inefficiente o non incapsulato per un facile riutilizzo. Volevo anche assicurarmi che restituisse false se la stringa era vuota o nulla. TryParse restituisce true in questo caso (una stringa vuota non causa un errore durante l'analisi come numero). Quindi, ecco il mio metodo di estensione stringa:

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

Semplice da usare:

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

Oppure, se si desidera testare altri tipi di numeri, è possibile specificare lo "stile". Quindi, per convertire un numero con un esponente, è possibile utilizzare:

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

O per testare una potenziale stringa esadecimale, è possibile utilizzare:

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

Il parametro facoltativo "cultura" può essere usato più o meno allo stesso modo.

È limitato dal fatto di non essere in grado di convertire stringhe troppo grandi per essere contenute in un doppio, ma questo è un requisito limitato e penso che se lavori con numeri più grandi di questo, probabilmente avrai bisogno di un'ulteriore gestione dei numeri specializzata funziona comunque.

È possibile utilizzare TryParse per determinare se la stringa può essere analizzata in un numero intero.

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

Il booleano ti dirà se ha funzionato o meno.

Se vuoi verificare se una stringa è un numero (suppongo sia una stringa poiché se è un numero, duh, sai che è uno).

• Senza regex e
• usando il codice di Microsoft il più possibile

potresti anche fare:

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

Questo si prenderà cura dei soliti Nasty:

• Meno (-) o Più (+) all'inizio
• contiene il carattere decimaleBigIntegers non analizzerà i numeri con punti decimali. (Quindi: BigInteger.Parse("3.3")genererà un'eccezione, e TryParseper lo stesso restituirà false)
• nessuna non cifra divertente
• copre i casi in cui il numero è maggiore del normale utilizzo di Double.TryParse

Dovrai aggiungere un riferimento System.Numericse avere using System.Numerics;in cima alla tua classe (beh, il secondo è un bonus immagino :)

Immagino che questa risposta andrà persa tra tutti gli altri, ma comunque, ecco qui.

Ho finito con questa domanda via Google perché volevo verificare se stringera numericcosì che potevo semplicemente usare al double.Parse("123")posto diTryParse() metodo.

Perché? Perché è fastidioso dover dichiarare una outvariabile e controllare il risultato TryParse()prima di sapere se l'analisi non è riuscita o meno. Voglio usare il ternary operatorper verificare se lo stringènumerical e quindi analizzarlo nella prima espressione ternaria o fornire un valore predefinito nella seconda espressione ternaria.

Come questo:

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

È solo molto più pulito di:

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

Ne ho fatti un paio extension methodsper questi casi:

Metodo di estensione uno

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

Esempio:

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

Perché IsParseableAs()cerca di analizzare la stringa come il tipo appropriato invece di controllare solo se la stringa è "numerica", dovrebbe essere abbastanza sicura. E puoi anche usarlo per tipi non numerici che hanno un TryParse()metodo, comeDateTime .

Il metodo usa la riflessione e finisci per chiamare il TryParse()metodo due volte che, ovviamente, non è così efficiente, ma non tutto deve essere completamente ottimizzato, a volte la convenienza è solo più importante.

Questo metodo può anche essere utilizzato per analizzare facilmente un elenco di stringhe numeriche in un elenco doubleo in qualche altro tipo con un valore predefinito senza dover rilevare alcuna eccezione:

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

Metodo di estensione due

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

Questo metodo di estensione consente di analizzare a stringcome qualsiasi altro typeche abbia aTryParse() metodo e ti consente anche di specificare un valore predefinito da restituire se la conversione non riesce.

Questo è meglio che usare l'operatore ternario con il metodo di estensione sopra come fa la conversione solo una volta. Usa ancora la riflessione però ...

Esempi:

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

Uscite:

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

Se vuoi sapere se una stringa è un numero, puoi sempre provare ad analizzarla:

var numberString = "123";
int number;

int.TryParse(numberString , out number);

Si noti che TryParserestituisce a bool, che è possibile utilizzare per verificare se l'analisi è riuscita.

Double.TryParse

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

AGGIORNAMENTO della risposta di Kunal Noel

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

Ma, in questo caso, abbiamo che le stringhe vuote supereranno quel test, quindi puoi:

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

La migliore soluzione flessibile con la funzione integrata .net chiamata- char.IsDigit. Funziona con numeri lunghi illimitati. Restituirà vero solo se ogni carattere è un numero numerico. L'ho usato molte volte senza problemi e con una soluzione molto più semplice che abbia mai trovato. Ho fatto un metodo di esempio, pronto per l'uso. Inoltre ho aggiunto la convalida per input nulli e vuoti. Quindi il metodo ora è totalmente a prova di proiettile

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

Con c # 7 puoi incorporare la variabile out:

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

Utilizzare questi metodi di estensione per distinguere chiaramente tra un controllo se la stringa è numerica e se la stringa contiene solo 0-9 cifre

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

Spero che sia di aiuto

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

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

Inserisci un riferimento a Visual Basic nel tuo progetto e usa il suo metodo Information.IsNumeric come mostrato sotto ed essere in grado di catturare float e numeri interi a differenza della risposta sopra che cattura solo ints.

    // Using Microsoft.VisualBasic;

    var txt = "ABCDEFG";

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

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

Prova le seguenti regole

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

Tutte le risposte sono utili. Ma durante la ricerca di una soluzione in cui il valore numerico è di 12 cifre o più (nel mio caso), quindi durante il debug, ho trovato utile la seguente soluzione:

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

La variabile risultante ti darà vero o falso.

Ecco il metodo C #. Metodo 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;
}