¿Cuál es el equivalente en C # de NaN o IsNumeric?

¿Cuál es la forma más eficiente de probar una cadena de entrada si contiene un valor numérico (o, por el contrario, no es un número)? Supongo que puedo usar Double.Parseo una expresión regular (ver más abajo) pero me preguntaba si hay alguna forma integrada de hacer esto, como javascript NaN()o IsNumeric()(¿era VB, no puedo recordar?).

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

Esto no tiene la sobrecarga de expresiones regulares

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

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

Por cierto, todos los tipos de datos estándar, con la flagrante excepción de los GUID, admiten TryParse.

update
secretwep mostró que el valor "2345" pasará la prueba anterior como un número. Sin embargo, si necesita asegurarse de que todos los caracteres dentro de la cadena sean dígitos, entonces debe tomar otro enfoque.

ejemplo 1 :

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

  return value;
}

o si quieres ser un poco mas elegante

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

actualización 2 (de @stackonfire para tratar con cadenas nulas o vacías)

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

Prefiero algo como esto, te permite decidir qué NumberStyleprobar.

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

Además de las respuestas correctas anteriores, probablemente valga la pena señalar que "No es un número" (NaN) en su uso general no es equivalente a una cadena que no puede evaluarse como un valor numérico. Por lo general, NaN se entiende como un valor numérico utilizado para representar el resultado de un cálculo "imposible", cuando el resultado no está definido. A este respecto, diría que el uso de Javascript es un poco engañoso. En C #, NaN se define como una propiedad de los tipos numéricos simple y doble y se usa para referirse explícitamente al resultado de bucear cero por cero. Otros lenguajes lo utilizan para representar diferentes valores "imposibles".

Sé que esto ha sido respondido de muchas maneras diferentes, con extensiones y ejemplos lambda, pero una combinación de ambos para la solución más simple.

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

o si está utilizando Visual Studio 2015 (C # 6.0 o superior), entonces

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

Impresionante C # 6 en una línea. Por supuesto, esto es limitado porque solo prueba solo caracteres numéricos.

Para usar, solo tenga una cadena y llame al método, como por ejemplo:

bool IsaNumber = "123456".IsNumeric();

Sí, IsNumeric es VB. Por lo general, la gente usa el método TryParse (), aunque es un poco torpe. Como sugirió, siempre puede escribir el suyo.

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

}

Me gusta el método de extensión, pero no me gusta lanzar excepciones si es posible. Opté por un método de extensión que toma la mejor de 2 respuestas aquí.

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

Aún puede usar la función de Visual Basic en C #. Lo único que tienes que hacer es seguir mis instrucciones que se muestran a continuación:

1. Agregue la referencia a la biblioteca de Visual Basic haciendo clic derecho en su proyecto y seleccionando "Agregar referencia":

2. Luego impórtelo en su clase como se muestra a continuación:

   utilizando Microsoft.VisualBasic;

3. A continuación, utilícelo donde desee, como se muestra a continuación:

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

¡Espero que esto ayude y buena suerte!

VB tiene la IsNumericfunción. Puede hacer referencia a él Microsoft.VisualBasic.dlly usarlo.

Extensión simple:

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

Tal vez esta sea una característica de C # 3, pero podría usarla double.NaN.

En realidad, Double.NaNes compatible con todas las versiones de .NET 2.0 y posteriores.

Estuve usando el fragmento de Chris Lively (respuesta seleccionada) encapsulado en una función bool como la sugerencia de Gishu durante un año o dos. Lo usé para asegurarme de que ciertas cadenas de consulta fueran solo numéricas antes de continuar con el procesamiento posterior. Comencé a recibir algunas cadenas de consulta erróneas que la respuesta marcada no manejaba, específicamente, cada vez que se pasaba una coma después de un número como "3645" (devuelto verdadero). Este es el mod resultante:

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

Tengo una versión ligeramente diferente que devuelve el número. Supongo que en la mayoría de los casos, después de probar la cadena, querrá usar el número.

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

Ésta es una versión modificada de la solución propuesta por el Sr. Siir. Encuentro que agregar un método de extensión es la mejor solución para la reutilización y la simplicidad en el método de llamada.

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

Modifiqué el cuerpo del método para que se ajustara a 2 líneas y eliminé la implementación innecesaria de .ToString (). Para aquellos que no están familiarizados con los métodos de extensión, aquí se explica cómo implementar:

Cree un archivo de clase llamado ExtensionMethods . Pega este código:

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

Reemplace YourNameSpaceHere con su NameSpace real. Guardar cambios. Ahora puede usar el método de extensión en cualquier lugar de su aplicación:

bool validInput = stringVariable.IsNumeric();

Nota: este método devolverá verdadero para enteros y decimales, pero devolverá falso si la cadena contiene una coma. Si desea aceptar la entrada con comas o símbolos como "$", sugeriría implementar un método para eliminar esos caracteres primero y luego probar si IsNumeric.