Identificar si una cadena es un número

Si tengo estas cadenas:

1. "abc" = false

2. "123" = true

3. "ab2" = false

¿Hay un comando, como IsNumeric()o algo más, que pueda identificar si una cadena es un número válido?

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

Actualización a partir de C # 7:

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

o si no necesita el número, puede descartar el parámetro de salida

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

¡Las var s pueden ser reemplazadas por sus respectivos tipos!

Esto devolverá verdadero si inputson todos los números. No sé si es mejor que TryParseeso, pero funcionará.

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

Si solo desea saber si tiene uno o más números mezclados con caracteres, omita el ^ +y $.

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

Editar: En realidad, creo que es mejor que TryParse porque una cadena muy larga podría potencialmente desbordar TryParse.

También puedes usar:

stringTest.All(char.IsDigit);

Volverá truepara todos los dígitos numéricos (no float) y falsesi la cadena de entrada es algún tipo de alfanumérico.

Tenga en cuenta : stringTestno debe ser una cadena vacía, ya que esto pasaría la prueba de ser numérico.

He usado esta función varias veces:

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

Pero también puedes usar;

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

De Benchmarking IsNumeric Options

_{(fuente: aspalliance.com )}

_{(fuente: aspalliance.com )}

Esta es probablemente la mejor opción en C #.

Si desea saber si la cadena contiene un número entero (entero):

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

El método TryParse intentará convertir la cadena en un número (entero) y, si tiene éxito, devolverá verdadero y colocará el número correspondiente en myInt. Si no puede, devuelve falso.

Las soluciones que usan la int.Parse(someString)alternativa que se muestra en otras respuestas funcionan, pero es mucho más lenta porque arrojar excepciones es muy costoso. TryParse(...)fue agregado al lenguaje C # en la versión 2, y hasta entonces no tenía elección. Ahora lo haces: por lo tanto, debes evitarParse() alternativa.

Si desea aceptar números decimales, la clase decimal también tiene un .TryParse(...)método. Reemplace int con decimal en la discusión anterior, y se aplican los mismos principios.

Siempre puede usar los métodos integrados TryParse para muchos tipos de datos para ver si la cadena en cuestión pasará.

Ejemplo.

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

El resultado sería entonces = verdadero

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

El resultado sería entonces = falso

En caso de que no quiera usar int.Parse o double.Parse, puede rodar el suyo con algo como esto:

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

Si desea capturar un espectro más amplio de números, al igual que is_numeric de PHP , puede usar lo siguiente:

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

Prueba de unidad:

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

Tenga en cuenta que solo porque un valor sea numérico no significa que se pueda convertir a un tipo numérico. Por ejemplo, "999999999999999999999999999999.9999999999"es un valor numérico válido perfecto, pero no cabe en un tipo numérico .NET (no está definido en la biblioteca estándar, es decir).

Sé que este es un hilo viejo, pero ninguna de las respuestas realmente lo hizo por mí, ya sea ineficiente o no encapsulado para una fácil reutilización. También quería asegurarme de que devuelve falso si la cadena estaba vacía o nula. TryParse devuelve verdadero en este caso (una cadena vacía no causa un error al analizar como un número). Entonces, aquí está mi método de extensión de cadena:

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

Fácil de usar:

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

O, si desea probar otros tipos de números, puede especificar el 'estilo'. Entonces, para convertir un número con un exponente, podría usar:

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

O para probar una posible cadena hexadecimal, puede usar:

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

El parámetro opcional 'cultura' se puede usar de la misma manera.

Está limitado por no poder convertir cadenas que son demasiado grandes para contener un doble, pero eso es un requisito limitado y creo que si está trabajando con números más grandes que esto, probablemente necesitará un manejo de números especializado adicional funciona de todos modos.

Puede usar TryParse para determinar si la cadena se puede analizar en un entero.

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

El booleano le dirá si funcionó o no.

Si desea verificar si una cadena es un número (supongo que es una cadena ya que si es un número, duh, ya sabe que es uno).

• Sin expresiones regulares y
• usando el código de Microsoft tanto como sea posible

también podrías hacer:

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

Esto se encargará de las molestias habituales:

• Menos (-) o Más (+) al principio
• contiene caracteres decimalesBigIntegers no analizará números con puntos decimales. (Entonces: BigInteger.Parse("3.3")arrojará una excepción, y TryParsepor lo mismo devolverá falso)
• no divertidos sin dígitos
• cubre casos donde el número es mayor que el uso habitual de Double.TryParse

Tendrás que agregar una referencia System.Numericsy tener la using System.Numerics;cima de tu clase (bueno, el segundo es un bono, supongo :)

Supongo que esta respuesta se perderá entre todas las demás, pero de todos modos, aquí va.

Terminé con esta pregunta a través de Google porque quería comprobar si stringera numericasí para poder usar en double.Parse("123")lugar del TryParse()método.

¿Por qué? Porque es molesto tener que declarar una outvariable y verificar el resultado TryParse()antes de saber si el análisis falló o no. Quiero usar el ternary operatorpara verificar si stringes numericaly luego simplemente analizarlo en la primera expresión ternaria o proporcionar un valor predeterminado en la segunda expresión ternaria.

Me gusta esto:

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

Es mucho más limpio que:

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

Hice un par extension methodspara estos casos:

Método de extensión 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);
}

Ejemplo:

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

Debido a que IsParseableAs()intenta analizar la cadena como el tipo apropiado en lugar de simplemente verificar si la cadena es "numérica", debería ser bastante segura. E incluso puede usarlo para tipos no numéricos que tienen un TryParse()método, comoDateTime .

El método usa la reflexión y terminas llamando al TryParse()método dos veces, lo que, por supuesto, no es tan eficiente, pero no todo tiene que estar completamente optimizado, a veces la conveniencia es más importante.

Este método también se puede utilizar para analizar fácilmente una lista de cadenas numéricas en una lista de doublealgún otro tipo con un valor predeterminado sin tener que detectar ninguna excepción:

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

Método de extensión dos

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

Este método de extensión le permite analizar un stringcomo cualquiera typeque tenga unTryParse() método y también le permite especificar un valor predeterminado para devolver si la conversión falla.

Esto es mejor que usar el operador ternario con el método de extensión anterior, ya que solo realiza la conversión una vez. Sin embargo, todavía usa la reflexión ...

Ejemplos:

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

Salidas:

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

Si desea saber si una cadena es un número, siempre puede intentar analizarla:

var numberString = "123";
int number;

int.TryParse(numberString , out number);

Tenga en cuenta que TryParsedevuelve un bool, que puede usar para verificar si su análisis se realizó correctamente.

Double. TryParse

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

ACTUALIZACIÓN de Kunal Noel Respuesta

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

Pero, para este caso, tenemos que las cadenas vacías pasarán esa prueba, por lo que puede:

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

La mejor solución flexible con la función incorporada .net llamada- char.IsDigit. Funciona con números largos ilimitados. Solo devolverá verdadero si cada carácter es un número numérico. Lo usé muchas veces sin problemas y con una solución mucho más limpia que encontré. Hice un método de ejemplo. Está listo para usar. Además, agregué validación para entradas nulas y vacías. Entonces el método ahora es totalmente a prueba 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;
            }
        }
    }

Con c # 7 puedes alinear la variable out:

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

Use estos métodos de extensión para distinguir claramente entre una verificación si la cadena es numérica y si la cadena solo contiene 0-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 esto ayude

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

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

Agregue una referencia a Visual Basic en su proyecto y use su método Information.IsNumeric, como se muestra a continuación, y pueda capturar flotantes y enteros, a diferencia de la respuesta anterior, que solo captura entradas.

    // Using Microsoft.VisualBasic;

    var txt = "ABCDEFG";

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

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

Prueba los reges a continuación

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

Todas las respuestas son útiles. Pero mientras buscaba una solución donde el valor numérico es de 12 dígitos o más (en mi caso), luego, mientras depuraba, encontré la siguiente solución útil:

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

La variable de resultado le dará verdadero o falso.

Aquí está el 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;
}