Identifique se uma sequência é um número

Se eu tiver essas strings:

1. "abc" = false

2. "123" = true

3. "ab2" = false

Existe um comando, como IsNumeric()algo assim, que pode identificar se uma string é um número válido?

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

Atualizar a partir do C # 7:

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

ou se você não precisar do número, pode descartar o parâmetro out

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

Os var s podem ser substituídos por seus respectivos tipos!

Isso retornará verdadeiro se inputhouver todos os números. Não sei se é melhor do que isso TryParse, mas funcionará.

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

Se você quiser apenas saber se ele possui um ou mais números misturados com caracteres, deixe de ^ +e $.

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

Edit: Na verdade, acho que é melhor que o TryParse, porque uma string muito longa pode potencialmente exceder o TryParse.

Você também pode usar:

stringTest.All(char.IsDigit);

Ele retornará truepara todos os dígitos numéricos (não float) e falsese a string de entrada for algum tipo de alfanumérico.

Observe : stringTestnão deve ser uma string vazia, pois isso passaria no teste de ser numérico.

Eu usei essa função várias vezes:

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

Mas você também pode usar;

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

A partir de Benchmarking Opções IsNumeric

_{(fonte: aspalliance.com )}

_{(fonte: aspalliance.com )}

Esta é provavelmente a melhor opção em c #.

Se você deseja saber se a sequência contém um número inteiro (número inteiro):

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

O método TryParse tentará converter a seqüência de caracteres em um número (número inteiro) e, se for bem-sucedido, retornará true e colocará o número correspondente em myInt. Se não puder, retorna falso.

As soluções que utilizam a int.Parse(someString)alternativa mostrada em outras respostas funcionam, mas são muito mais lentas, porque lançar exceções é muito caro. TryParse(...)foi adicionado ao idioma C # na versão 2 e até então você não tinha escolha. Agora você faz: você deve, portanto, evitar oParse() alternativa.

Se você deseja aceitar números decimais, a classe decimal também possui um .TryParse(...)método. Substitua int por decimal na discussão acima, e os mesmos princípios se aplicam.

Você sempre pode usar os métodos TryParse incorporados para muitos tipos de dados para verificar se a sequência em questão será aprovada.

Exemplo.

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

O resultado seria então = True

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

O resultado seria então = False

Caso você não queira usar int.Parse ou double.Parse, você pode criar o seu próprio com algo como isto:

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 você deseja capturar um espectro mais amplo de números, como is_numeric do PHP , pode usar o seguinte:

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

Teste de unidade:

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

Lembre-se de que o fato de um valor ser numérico não significa que ele pode ser convertido em um tipo numérico. Por exemplo, "999999999999999999999999999999.9999999999"é um valor numérico válido perfeitamente, mas não se encaixa em um tipo numérico do .NET (não definido na biblioteca padrão).

Sei que esse é um tópico antigo, mas nenhuma das respostas realmente fez isso por mim - ineficiente ou não encapsulado para facilitar a reutilização. Eu também queria garantir que ele retornasse false se a string estivesse vazia ou nula. TryParse retorna true nesse caso (uma cadeia vazia não causa um erro ao analisar como um número). Então, aqui está o meu método de extensão de string:

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

Simples de usar:

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

Ou, se você quiser testar outros tipos de número, poderá especificar o 'estilo'. Portanto, para converter um número com um expoente, você pode usar:

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

Ou, para testar uma potencial sequência Hex, você pode usar:

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

O parâmetro opcional 'cultura' pode ser usado da mesma maneira.

É limitado por não ser capaz de converter cadeias grandes demais para serem contidas em um duplo, mas isso é um requisito limitado e acho que se você estiver trabalhando com números maiores que isso, provavelmente precisará de um tratamento especializado adicional. funciona de qualquer maneira.

Você pode usar o TryParse para determinar se a sequência pode ser analisada em um número inteiro.

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

O booleano dirá se funcionou ou não.

Se você quiser verificar se uma string é um número (suponho que seja uma string, pois se for um número, você sabe que é uma).

• Sem regex e
• usando o código da Microsoft, tanto quanto possível

você também pode fazer:

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

Isso cuidará dos problemas comuns:

• Menos (-) ou Mais (+) no início
• contém caracteres decimaisBigIntegers não analisará números com pontos decimais. (Então: BigInteger.Parse("3.3")lançará uma exceção eTryParse pelo mesmo, retornará falso)
• sem dígitos engraçados
• abrange casos em que o número é maior que o uso usual de Double.TryParse

Você terá que adicionar uma referência System.Numericse ter using System.Numerics;no topo da sua classe (bem, o segundo é um bônus, eu acho :)

Eu acho que essa resposta será perdida entre todas as outras, mas de qualquer maneira, aqui vai.

Acabei com essa pergunta pelo Google porque queria verificar se a stringera numericpara que eu pudesse usar em double.Parse("123")vez do TryParse()método.

Por quê? Porque é irritante ter que declarar uma outvariável e verificar o resultado TryParse()antes que você saiba se a análise falhou ou não. Eu quero usar o ternary operatorpara verificar se o stringé numericale apenas analisá-lo na primeira expressão ternária ou fornecer um valor padrão na segunda expressão ternária.

Como isso:

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

É muito mais limpo do que:

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

Fiz alguns extension methodspara estes casos:

Método de extensão um

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

Exemplo:

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

Como IsParseableAs()tenta analisar a sequência como o tipo apropriado, em vez de apenas verificar se a sequência é "numérica", deve ser bastante seguro. E você pode até usá-lo para tipos não numéricos que possuem um TryParse()método, comoDateTime .

O método usa reflexão e você acaba chamando o TryParse()método duas vezes, o que, obviamente, não é tão eficiente, mas nem tudo precisa ser totalmente otimizado; às vezes, a conveniência é apenas mais importante.

Esse método também pode ser usado para analisar facilmente uma lista de seqüências numéricas em uma lista de doubleou outro tipo com um valor padrão sem a necessidade de capturar nenhuma exceção:

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

Método de extensão dois

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

Esse método de extensão permite analisar a stringcomo qualquer um typeque tenha umaTryParse() método e também permite especificar um valor padrão a ser retornado se a conversão falhar.

Isso é melhor do que usar o operador ternário com o método de extensão acima, pois ele faz a conversão apenas uma vez. Ainda usa reflexão ...

Exemplos:

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

Saídas:

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

Se você quiser saber se uma sequência é um número, tente sempre analisá-la:

var numberString = "123";
int number;

int.TryParse(numberString , out number);

Observe que TryParseretorna a bool, que você pode usar para verificar se sua análise foi bem-sucedida.

Double.TryParse

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

ATUALIZAÇÃO da resposta de Kunal Noel

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

Mas, nesse caso, temos que cadeias vazias passarão no teste; portanto, você pode:

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

A melhor solução flexível com a função incorporada .net chamada- char.IsDigit. Funciona com números longos ilimitados. Só retornará true se cada caractere for um número numérico. Usei-o muitas vezes sem problemas e com uma solução muito mais limpa que encontrei. Eu fiz um método de exemplo. Está pronto para usar. Além disso, adicionei validação para entrada nula e vazia. Portanto, o método agora é totalmente à prova de balas

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

Com o c # 7, você pode incorporar a variável out:

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

Use esses métodos de extensão para distinguir claramente entre uma verificação se a sequência é numérica e se a sequência contém apenas de 0 a 9 dígitos

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

Espero que isto ajude

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

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

Puxe uma referência ao Visual Basic em seu projeto e use o método Information.IsNumeric, como mostrado abaixo, e possa capturar carros alegóricos e números inteiros, ao contrário da resposta acima, que captura apenas ints.

    // Using Microsoft.VisualBasic;

    var txt = "ABCDEFG";

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

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

Experimente as regras abaixo

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

Todas as respostas são úteis. Mas, ao procurar uma solução em que o valor numérico tenha 12 dígitos ou mais (no meu caso), durante a depuração, achei a seguinte solução útil:

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

A variável de resultado fornecerá verdadeiro ou falso.

Aqui está o método C #. Método 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;
}