Qual é o equivalente em C # de NaN ou IsNumeric?

Qual é a maneira mais eficiente de testar uma string de entrada se ela contém um valor numérico (ou, inversamente, Não é um número)? Eu acho que posso usar Double.Parseou um regex (veja abaixo), mas eu queria saber se existe alguma forma embutida de fazer isso, como javascript NaN()ou IsNumeric()(era VB, não me lembro?).

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

Isso não tem sobrecarga de 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
}

A propósito, todos os tipos de dados padrão, com a notável exceção de GUIDs, oferecem suporte a TryParse.

update
secretwep mostrou que o valor "2345" passará no teste acima como um número. No entanto, se você precisar garantir que todos os caracteres na string sejam dígitos, outra abordagem deve ser adotada.

exemplo 1 :

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

  return value;
}

ou se você quer ser um pouco mais chique

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

atualização 2 (de @stackonfire para lidar com strings nulas ou vazias)

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

Eu prefiro algo assim, permite que você decida o NumberStyleque testar.

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

Além das respostas corretas anteriores, provavelmente vale a pena apontar que "Not a Number" (NaN) em seu uso geral não é equivalente a uma string que não pode ser avaliada como um valor numérico. NaN é geralmente entendido como um valor numérico usado para representar o resultado de um cálculo "impossível" - onde o resultado é indefinido. A este respeito, eu diria que o uso de Javascript é um pouco enganador. Em C # NaN é definido como uma propriedade dos tipos numéricos simples e duplos e é usado para se referir explicitamente ao resultado do mergulho zero a zero. Outras linguagens o usam para representar diferentes valores "impossíveis".

Eu sei que isso foi respondido de muitas maneiras diferentes, com extensões e exemplos lambda, mas uma combinação de ambos para a solução mais simples.

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

ou se você estiver usando o Visual Studio 2015 (C # 6.0 ou superior),

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

Excelente C # 6 em uma linha. É claro que isso é limitado porque testa apenas caracteres numéricos.

Para usar, basta ter uma string e chamar o método nela, como:

bool IsaNumber = "123456".IsNumeric();

Sim, IsNumeric é VB. Normalmente as pessoas usam o método TryParse (), embora seja um pouco desajeitado. Como você sugeriu, você sempre pode escrever o seu próprio.

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

}

Eu gosto do método de extensão, mas não gosto de lançar exceções, se possível. Optei por um método de extensão obtendo a melhor de 2 respostas aqui.

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

Você ainda pode usar a função Visual Basic em C #. A única coisa que você precisa fazer é apenas seguir minhas instruções mostradas abaixo:

1. Adicione a referência à Biblioteca do Visual Basic clicando com o botão direito do mouse em seu projeto e selecionando "Adicionar Referência":

2. Em seguida, importe -o em sua classe, conforme mostrado abaixo:

   using Microsoft.VisualBasic;

3. Em seguida, use-o onde quiser, conforme mostrado abaixo:

               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 isso ajude e boa sorte!

O VB tem a IsNumericfunção. Você pode fazer referência Microsoft.VisualBasic.dlle usá-lo.

Extensão simples:

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

Talvez seja um recurso do C # 3, mas você pode usar double.NaN.

Na verdade, Double.NaNé compatível com todas as versões do .NET 2.0 e superiores.

Eu estava usando o snippet (resposta selecionada) de Chris Lively encapsulado em uma função bool como a sugestão de Gishu por um ou dois anos. Usei-o para ter certeza de que certas strings de consulta eram apenas numéricas antes de prosseguir com o processamento. Comecei a receber algumas strings de consulta erradas que a resposta marcada não estava manipulando, especificamente, sempre que uma vírgula era passada após um número como "3645" (retornado verdadeiro). Este é o 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;
      }
   }

Tenho uma versão ligeiramente diferente que retorna o número. Eu acho que na maioria dos casos, depois de testar a string, você gostaria de usar o número.

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

Esta é uma versão modificada da solução proposta pelo Sr. Siir. Acho que adicionar um método de extensão é a melhor solução para reutilização e simplicidade no método de chamada.

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

Modifiquei o corpo do método para caber em 2 linhas e removi a implementação desnecessária de .ToString (). Para quem não está familiarizado com os métodos de extensão, aqui está como implementar:

Crie um arquivo de classe chamado ExtensionMethods . Cole neste 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; }
        }
    }
}

Substitua YourNameSpaceHere pelo seu NameSpace real. Salve as alterações. Agora você pode usar o método de extensão em qualquer lugar do seu aplicativo:

bool validInput = stringVariable.IsNumeric();

Observação: este método retornará verdadeiro para inteiros e decimais, mas retornará falso se a string contiver uma vírgula. Se você quiser aceitar a entrada com vírgulas ou símbolos como "$", sugiro implementar um método para remover esses caracteres primeiro e depois testar se IsNumeric.