Qual è l'equivalente in C # di NaN o IsNumeric?

Qual è il modo più efficiente per testare una stringa di input se contiene un valore numerico (o al contrario Non un numero)? Immagino di poter usare Double.Parseo una regex (vedi sotto) ma mi chiedevo se ci fosse un modo integrato per farlo, come javascript NaN()o IsNumeric()(era VB, non ricordo?).

public static bool IsNumeric(this string value)
{
    return Regex.IsMatch(value, "^\\d+$");
}

Questo non ha l'overhead di regex

double myNum = 0;
String testVar = "Not A Number";

if (Double.TryParse(testVar, out myNum)) {
  // it is a number
} else {
  // it is not a number
}

Per inciso, tutti i tipi di dati standard, con l'eccezione lampante dei GUID, supportano TryParse.

update
secretwep ha evidenziato che il valore "2345" supererà il test precedente come numero. Tuttavia, se è necessario assicurarsi che tutti i caratteri all'interno della stringa siano cifre, è necessario adottare un altro approccio.

esempio 1 :

public Boolean IsNumber(String s) {
  Boolean value = true;
  foreach(Char c in s.ToCharArray()) {
    value = value && Char.IsDigit(c);
  }

  return value;
}

o se vuoi essere un po 'più stravagante

public Boolean IsNumber(String value) {
  return value.All(Char.IsDigit);
}

aggiornamento 2 (da @stackonfire per gestire stringhe nulle o vuote)

public Boolean IsNumber(String s) { 
    Boolean value = true; 
    if (s == String.Empty || s == null) { 
        value=false; 
    } else { 
        foreach(Char c in s.ToCharArray()) { 
            value = value && Char.IsDigit(c); 
        } 
    } return value; 
}

Preferisco qualcosa di simile, ti permette di decidere cosa NumberStyleprovare.

public static Boolean IsNumeric(String input, NumberStyles numberStyle) {
    Double temp;
    Boolean result = Double.TryParse(input, numberStyle, CultureInfo.CurrentCulture, out temp);
    return result;
}

In aggiunta alle precedenti risposte corrette è probabilmente opportuno sottolineare che "Not a Number" (NaN) nel suo utilizzo generale non è equivalente a una stringa che non può essere valutata come valore numerico. NaN è generalmente inteso come un valore numerico utilizzato per rappresentare il risultato di un calcolo "impossibile", in cui il risultato è indefinito. A questo proposito, direi che l'utilizzo di Javascript è leggermente fuorviante. In C # NaN è definito come una proprietà dei tipi numerici singoli e doppi e viene utilizzato per fare riferimento esplicitamente al risultato dell'immersione zero per zero. Altre lingue lo usano per rappresentare diversi valori "impossibili".

So che è stato risposto in molti modi diversi, con estensioni ed esempi lambda, ma una combinazione di entrambi per la soluzione più semplice.

public static bool IsNumeric(this String s)
{
    return s.All(Char.IsDigit);
}

o se utilizzi Visual Studio 2015 (C # 6.0 o versione successiva)

public static bool IsNumeric(this String s) => s.All(Char.IsDigit);

Fantastico C # 6 su una riga. Ovviamente questo è limitato perché verifica solo i caratteri numerici.

Per usarlo, basta avere una stringa e chiamare il metodo su di essa, ad esempio:

bool IsaNumber = "123456".IsNumeric();

Sì, IsNumeric è VB. Di solito le persone usano il metodo TryParse (), sebbene sia un po 'goffo. Come hai suggerito, puoi sempre scrivere il tuo.

int i;
if (int.TryParse(string, out i))
{

}

Mi piace il metodo di estensione, ma non mi piace lanciare eccezioni se possibile. Ho optato per un metodo di estensione che prende la migliore delle 2 risposte qui.

    /// <summary>
    /// Extension method that works out if a string is numeric or not
    /// </summary>
    /// <param name="str">string that may be a number</param>
    /// <returns>true if numeric, false if not</returns>
    public static bool IsNumeric(this String str)
    {
        double myNum = 0;
        if (Double.TryParse(str, out myNum))
        {
            return true;
        }
        return false;
    }

È comunque possibile utilizzare la funzione Visual Basic in C #. L'unica cosa che devi fare è seguire le mie istruzioni mostrate di seguito:

1. Aggiungi il riferimento alla libreria di Visual Basic facendo clic con il pulsante destro del mouse sul tuo progetto e selezionando "Aggiungi riferimento":

2. Quindi importalo nella tua classe come mostrato di seguito:

   using Microsoft.VisualBasic;

3. Quindi usalo dove vuoi come mostrato di seguito:

               if (!Information.IsNumeric(softwareVersion))
           {
               throw new DataException(string.Format("[{0}] is an invalid App Version!  Only numeric values are supported at this time.", softwareVersion));
           }

Spero, questo aiuta e buona fortuna!

VB ha la IsNumericfunzione. Puoi fare riferimento Microsoft.VisualBasic.dlle usarlo.

Semplice estensione:

public static bool IsNumeric(this String str)
{
    try
    {
        Double.Parse(str.ToString());
        return true;
    }
    catch {
    }
    return false;
}

public static bool IsNumeric(string anyString)
{
    if (anyString == null)
    {
        anyString = "";
    }

    if (anyString.Length > 0)
    {
        double dummyOut = new double();
        System.Globalization.CultureInfo cultureInfo = new System.Globalization.CultureInfo("en-US", true);
        return Double.TryParse(anyString, System.Globalization.NumberStyles.Any, cultureInfo.NumberFormat, out dummyOut);
    }
    else
    {
        return false;
    }
}

Forse questa è una funzionalità C # 3, ma potresti usare double.NaN.

In realtà, Double.NaNè supportato in tutte le versioni .NET 2.0 e successive.

Stavo usando lo snippet di Chris Lively (risposta selezionata) incapsulato in una funzione bool come il suggerimento di Gishu per un anno o due. L'ho usato per assicurarmi che alcune stringhe di query fossero solo numeriche prima di procedere con un'ulteriore elaborazione. Ho iniziato a ricevere alcune stringhe di query errate che la risposta contrassegnata non stava gestendo, in particolare, ogni volta che una virgola veniva passata dopo un numero come "3645" (restituito vero). Questa è la mod risultante:

   static public bool IsNumeric(string s)
   {
      double myNum = 0;
      if (Double.TryParse(s, out myNum))
      {
         if (s.Contains(",")) return false;
         return true;
      }
      else
      {
         return false;
      }
   }

Ho una versione leggermente diversa che restituisce il numero. Immagino che nella maggior parte dei casi dopo aver testato la stringa dovresti utilizzare il numero.

public bool IsNumeric(string numericString, out Double numericValue)
{
    if (Double.TryParse(numericString, out numericValue))
        return true;
    else
        return false;
}

Questa è una versione modificata della soluzione proposta dall'onorevole Siir. Trovo che l'aggiunta di un metodo di estensione sia la soluzione migliore per il riutilizzo e la semplicità nel metodo di chiamata.

public static bool IsNumeric(this String s)
{
    try { double.Parse(s); return true; }
    catch (Exception) { return false; }
}

Ho modificato il corpo del metodo per adattarlo a 2 righe e ho rimosso l'implementazione non necessaria .ToString (). Per coloro che non hanno familiarità con i metodi di estensione, ecco come implementare:

Crea un file di classe chiamato ExtensionMethods . Incolla questo codice:

using System;
using System.Collections.Generic;
using System.Text;

namespace YourNameSpaceHere
{
    public static class ExtensionMethods
    {
        public static bool IsNumeric(this String s)
        {
            try { double.Parse(s); return true; }
            catch (Exception) { return false; }
        }
    }
}

Sostituisci YourNameSpaceHere con il tuo NameSpace effettivo. Salvare le modifiche. Ora puoi utilizzare il metodo di estensione ovunque nella tua app:

bool validInput = stringVariable.IsNumeric();

Nota: questo metodo restituirà true per numeri interi e decimali, ma restituirà false se la stringa contiene una virgola. Se si desidera accettare l'input con virgole o simboli come "$", suggerirei di implementare un metodo per rimuovere prima quei caratteri, quindi verificare se IsNumeric.