¿Cómo puedo convertir String a Int?

Tengo un TextBoxD1.Text y quiero convertirlo en un int para almacenarlo en una base de datos.

¿Cómo puedo hacer esto?

preguntado el 19 de junio de 09 a las 17:06

¿Hay algún inconveniente específico al usar Convert.ToInt32 () -

30 Respuestas

Prueba esto:

int x = Int32.Parse(TextBoxD1.Text);

o mejor aún:

int x = 0;

Int32.TryParse(TextBoxD1.Text, out x);

Además, desde Int32.TryParse devuelve un bool puede usar su valor de retorno para tomar decisiones sobre los resultados del intento de análisis:

int x = 0;

if (Int32.TryParse(TextBoxD1.Text, out x))
{
    // you know that the parsing attempt
    // was successful
}

Si tiene curiosidad, la diferencia entre Parse y TryParse se resume mejor así:

El método TryParse es como el método Parse, excepto que el método TryParse no genera una excepción si falla la conversión. Elimina la necesidad de utilizar el manejo de excepciones para probar una FormatException en caso de que s no sea válido y no se pueda analizar correctamente. - MSDN

Respondido 20 Jul 16, 21:07

¿Qué sucede si el número entero es de 64 bits o se parece a "aslkdlksadjsd"? ¿Sigue siendo seguro? - Jonny

@jonny Int64.Parse(). Si la entrada no es int, obtendrá una excepción y un seguimiento de pila con Int64.Parse, o el booleano False con Int64.TryParse(), por lo que necesitaría una declaración if, como if (Int32.TryParse(TextBoxD1.Text, out x)) {}. - usuario4409948

También puede intentar inicializar la variable en TryParse si se va a usar solo dentro de la condición de éxito. por ejemplo: Int32.TryParse (TextBoxD1.Text, out int x)) - simplemente

Tal vez esto sea increíblemente obvio para todos los demás, pero para los novatos lo que hace 'out x' es establecer el valor de x en el string-cast-as-integer, si el casting tiene éxito. Es decir, en este caso, x = 0 si la cadena tiene caracteres no enteros, o x = valor de cadena como entero en caso contrario. Entonces, lo bueno es que esta es una expresión corta que le dice si la conversión es exitosa o no, Y almacena el entero de conversión en una variable al mismo tiempo. Obviamente, a menudo querrá continuar la línea anterior con 'else {// la cadena analizada no es un entero, por lo tanto, algún código para manejar esta situación}' - croxford

@Roberto ok, pero es posible que el usuario (ya sea por error o intencionalmente) escriba el valor "aslkdlksadjsd" dentro de un cuadro de texto. entonces, ¿debería fallar nuestro programa? - S. Serpooshan

Convert.ToInt32( TextBoxD1.Text );

Use esto si está seguro de que el contenido del cuadro de texto es válido int. Una opción más segura es

int val = 0;
Int32.TryParse( TextBoxD1.Text, out val );

Esto le proporcionará un valor predeterminado que puede utilizar. Int32.TryParse también devuelve un valor booleano que indica si fue capaz de analizar o no, por lo que incluso puede usarlo como condición de un if .

if( Int32.TryParse( TextBoxD1.Text, out val ){
  DoSomething(..);
} else {
  HandleBadInput(..);
}

Respondido 27 Abr '20, 22:04

-1 RE. "Esto le proporcionará un valor predeterminado que puede utilizar". Si se refiere a val, espere problemas: "Este parámetro se pasa sin inicializar; se sobrescribirá cualquier valor proporcionado originalmente en el resultado". [Árbitro. docs.microsoft.com/en-us/dotnet/api/… ]- Zeek2

Hace 10 años me disculpo. - Babak Nafas

int.TryParse()

No arrojará si el texto no es numérico.

Respondido 03 Abr '11, 19:04

Esto es mejor que los otros dos. Es probable que la entrada del usuario tenga un formato incorrecto. Este es más eficiente que usar el manejo de excepciones como lo requieren los demás. - tío O

Exactamente. Devuelve falso si la conversión falló. - n8wrl

int myInt = int.Parse(TextBoxD1.Text)

Otra forma sería:

bool isConvertible = false;
int myInt = 0;

isConvertible = int.TryParse(TextBoxD1.Text, out myInt);

La diferencia entre los dos es que el primero arrojaría una excepción si el valor en su cuadro de texto no se puede convertir, mientras que el segundo simplemente devolvería falso.

contestado el 26 de mayo de 14 a las 09:05

La variable booleana anterior es muy útil, estamos usando el valor convertido para comaprison, digamos en una cláusula if. code int NumericJL; bool isNum = int.TryParse (nomeeJobBand, fuera NumericJL); if (isNum) // El JL recuperado es capaz de pegar a int, luego continúe con la comparación {if (! (NumericJL> = 6)) {// Nominate} // else {}} - Baymax

Debe analizar la cadena y también debe asegurarse de que realmente tenga el formato de un número entero.

La forma más sencilla es la siguiente:

int parsedInt = 0;
if (int.TryParse(TextBoxD1.Text, out parsedInt))
{
   // Code for if the string was valid
}
else
{
   // Code for if the string was invalid
}

Respondido el 19 de junio de 09 a las 21:06

Tenga cuidado al usar Convert.ToInt32() en un char! Devolverá el UTF-16 código del personaje!

Si accede a la cadena solo en una determinada posición utilizando el [i] operador de indexación, devolverá un char y no un string!

String input = "123678";
                    ^
                    |
int indexOfSeven =  4;

int x = Convert.ToInt32(input[indexOfSeven]);             // Returns 55

int x = Convert.ToInt32(input[indexOfSeven].toString());  // Returns 7

Respondido el 17 de junio de 20 a las 09:06

int x = 0;
int.TryParse(TextBoxD1.Text, out x);

La instrucción TryParse devuelve un valor booleano que representa si el análisis se ha realizado correctamente o no. Si tuvo éxito, el valor analizado se almacena en el segundo parámetro.

Ver Método Int32. TryParse (String, Int32) para obtener información más detallada.

contestado el 26 de mayo de 14 a las 09:05

Disfrútala...

int i = 0;
string s = "123";
i =int.Parse(s);
i = Convert.ToInt32(s);

Respondido 16 ago 16, 19:08

Si bien ya hay muchas soluciones aquí que describen int.Parse, falta algo importante en todas las respuestas. Normalmente, las representaciones de cadena de valores numéricos difieren según la cultura. Los elementos de cadenas numéricas como símbolos de moneda, separadores de grupos (o miles) y separadores decimales varían según la cultura.

Si desea crear una forma sólida de analizar una cadena en un número entero, es importante tener en cuenta la información de la cultura. Si no lo hace, el entorno cultural actual se utilizará. Eso podría darle al usuario una sorpresa bastante desagradable, o incluso peor, si está analizando formatos de archivo. Si solo desea el análisis sintáctico en inglés, lo mejor es simplemente hacerlo explícito, especificando la configuración cultural que se utilizará:

var culture = CultureInfo.GetCulture("en-US");
int result = 0;
if (int.TryParse(myString, NumberStyles.Integer, culture, out result))
{
    // use result...
}

Para obtener más información, lea sobre CultureInfo, específicamente Información de formato de número en MSDN.

Respondido 06 Jul 15, 12:07

Puedes escribir tu propio método de extensión

public static class IntegerExtensions
{
    public static int ParseInt(this string value, int defaultValue = 0)
    {
        int parsedValue;
        if (int.TryParse(value, out parsedValue))
        {
            return parsedValue;
        }

        return defaultValue;
    }

    public static int? ParseNullableInt(this string value)
    {
        if (string.IsNullOrEmpty(value))
        {
            return null;
        }

        return value.ParseInt();
    }
}

Y en cualquier lugar del código, solo llama

int myNumber = someString.ParseInt(); // Returns value or 0
int age = someString.ParseInt(18); // With default value 18
int? userId = someString.ParseNullableInt(); // Returns value or null

En este caso concreto

int yourValue = TextBoxD1.Text.ParseInt();

Respondido 27 Abr '20, 22:04

¿No debería llamarse a la clase? StringExtensions en lugar de IntegerExtensions, ya que estos métodos de extensión actúan sobre una string y no en un int? - Shiva

int x = Int32.TryParse(TextBoxD1.Text, out x) ? x : 0;

Respondido 27 Abr '20, 22:04

Como se explica en el Documentación de TryParse, TryParse () devuelve un booleano que indica que se encontró un número válido:

bool success = Int32.TryParse(TextBoxD1.Text, out val);

if (success)
{
    // Put val in database
}
else
{
    // Handle the case that the string doesn't contain a valid number
}

Respondido 27 Abr '20, 22:04

//May be quite some time ago but I just want throw in some line for any one who may still need it

int intValue;
string strValue = "2021";

try
{
    intValue = Convert.ToInt32(strValue);
}
catch
{
    //Default Value if conversion fails OR return specified error
    // Example 
    intValue = 2000;
}

Respondido 27 Feb 17, 07:02

Incumplir en este caso no sería una buena idea. Si se requiere un incumplimiento de manera crucial, recomiendo devolver 0. - Prageeth Saravanan

Puedes usar cualquiera,

int i = Convert.ToInt32(TextBoxD1.Text);

or

int i = int.Parse(TextBoxD1.Text);

Respondido 27 Abr '20, 22:04

¿En qué se diferencia esto de las respuestas anteriores? - Pedro Mortensen

También puede utilizar un método de extensión, por lo que será más legible (aunque todos ya están acostumbrados a las funciones regulares de Parse).

public static class StringExtensions
{
    /// <summary>
    /// Converts a string to int.
    /// </summary>
    /// <param name="value">The string to convert.</param>
    /// <returns>The converted integer.</returns>
    public static int ParseToInt32(this string value)
    {
        return int.Parse(value);
    }

    /// <summary>
    /// Checks whether the value is integer.
    /// </summary>
    /// <param name="value">The string to check.</param>
    /// <param name="result">The out int parameter.</param>
    /// <returns>true if the value is an integer; otherwise, false.</returns>
    public static bool TryParseToInt32(this string value, out int result)
    {
        return int.TryParse(value, out result);
    }
}

Y luego puedes llamarlo de esa manera:

  1. Si está seguro de que su cadena es un número entero, como "50".

    int num = TextBoxD1.Text.ParseToInt32();
    
  2. Si no está seguro y desea evitar accidentes.

    int num;
    if (TextBoxD1.Text.TryParseToInt32(out num))
    {
        //The parse was successful, the num has the parsed value.
    }
    

Para hacerlo más dinámico, para que pueda analizarlo también para duplicar, flotar, etc., puede crear una extensión genérica.

contestado el 26 de mayo de 14 a las 10:05

Conversión de string a int se puede hacer para: int, Int32, Int64 y otros tipos de datos que reflejan tipos de datos enteros en .NET

El siguiente ejemplo muestra esta conversión:

Este elemento del adaptador de datos de la demostración (para la información) se inicializó al valor int. Lo mismo se puede hacer directamente como,

int xxiiqVal = Int32.Parse(strNabcd);

Ex.

string strNii = "";
UsrDataAdapter.SelectCommand.Parameters["@Nii"].Value = Int32.Parse(strNii );

Enlace para ver esta demostración.

Respondido 27 Jul 16, 10:07

Puede convertir una cadena a int en C # usando:

Funciones de la clase de conversión ie Convert.ToInt16(), Convert.ToInt32(), Convert.ToInt64() o usando Parse y TryParse Funciones. Se dan ejemplos aquí.

contestado el 11 de mayo de 18 a las 07:05

¿En qué se diferencia esto de las respuestas anteriores? - Pedro Mortensen

Esto serviría

string x = TextBoxD1.Text;
int xi = Convert.ToInt32(x);

O puede utilizar

int xi = Int32.Parse(x);

Remitir Microsoft Developer Network para obtener más información

Respondido 27 Abr '20, 22:04

¿En qué se diferencia esto de las respuestas anteriores? - Pedro Mortensen

Puede hacer lo siguiente sin TryParse o funciones integradas:

static int convertToInt(string a)
{
    int x = 0;
    for (int i = 0; i < a.Length; i++)
    {
        int temp = a[i] - '0';
        if (temp != 0)
        {
            x += temp * (int)Math.Pow(10, (a.Length - (i+1)));
        }
    }
    return x;
}

Respondido 27 Abr '20, 23:04

convertToInt ("1234") da 10000 ...... si va a copiar la respuesta de otra persona, al menos copie todo - Serenidad ahora

no me compares contigo mismo .. agrega una solución actualizada en su lugar .. jajaja - perezoso

@SerenityNow ya puedes comprobarlo. Fue un error tipográfico. - perezoso

refiriéndose a su identificación, un perezoso-¡El desarrollador no creará tal método! ; D bueno - S. Serpooshan

int i = Convert.ToInt32(TextBoxD1.Text);

Respondido 03 Abr '11, 18:04

Una explicación estaría en orden. Por ejemplo, ¿en qué se diferencia de La respuesta de Babak Naffas? - Pedro Mortensen

Puede convertir cadenas a int muchos métodos de tipo diferentes en C #

El primero es principalmente de uso:

string test = "123";
int x = Convert.ToInt16(test);

si el valor int es mayor, debe usar el tipo int32.

Segunda:

int x = int.Parse(text);

si desea verificar errores, puede usar el método TryParse. A continuación, agrego un tipo que acepta valores NULL;

int i=0;
Int32.TryParse(text, out i) ? i : (int?)null);

Disfruta tus códigos ...

Respondido 09 Oct 20, 11:10

Puede convertir una cadena en un valor entero con la ayuda del método de análisis.

P.ej:

int val = Int32.parse(stringToBeParsed);
int x = Int32.parse(1234);

Respondido 17 Oct 18, 09:10

¿En qué se diferencia esto de las respuestas anteriores? - Pedro Mortensen

La forma en que siempre hago esto es así:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace example_string_to_int
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            string a = textBox1.Text;
            // This turns the text in text box 1 into a string
            int b;
            if (!int.TryParse(a, out b))
            {
                MessageBox.Show("This is not a number");
            }
            else
            {
                textBox2.Text = a+" is a number" ;
            }
            // Then this 'if' statement says if the string is not a number, display an error, else now you will have an integer.
        }
    }
}

Así es como lo haría yo.

Respondido 27 Abr '20, 22:04

En C # v.7, podría usar un parámetro inline out, sin una declaración de variable adicional:

int.TryParse(TextBoxD1.Text, out int x);

Respondido 27 Abr '20, 23:04

No son out parámetros desalentados en C # ahora? - Pedro Mortensen

Si está buscando el camino más largo, simplemente cree su único método:

static int convertToInt(string a)
    {
        int x = 0;

        Char[] charArray = a.ToCharArray();
        int j = charArray.Length;

        for (int i = 0; i < charArray.Length; i++)
        {
            j--;
            int s = (int)Math.Pow(10, j);

            x += ((int)Char.GetNumericValue(charArray[i]) * s);
        }
        return x;
    }

Respondido el 05 de junio de 17 a las 13:06

MÉTODO 1

int  TheAnswer1 = 0;
bool Success = Int32.TryParse("42", out TheAnswer1);
if (!Success) {
    Console.WriteLine("String not Convertable to an Integer");
}

MÉTODO 2

int TheAnswer2 = 0;
try {
    TheAnswer2 = Int32.Parse("42");
}
catch {
    Console.WriteLine("String not Convertable to an Integer");
}

MÉTODO 3

int TheAnswer3 = 0;
try {
    TheAnswer3 = Int32.Parse("42");
}
catch (FormatException) {
    Console.WriteLine("String not in the correct format for an Integer");
}
catch (ArgumentNullException) {
    Console.WriteLine("String is null");
}
catch (OverflowException) {
    Console.WriteLine("String represents a number less than"
                      + "MinValue or greater than MaxValue");
}

Respondido 18 Oct 17, 13:10

Este código me funciona en Visual Studio 2010:

int someValue = Convert.ToInt32(TextBoxD1.Text);

Respondido el 02 de enero de 18 a las 12:01

Sí, pero ¿en qué se diferencia de las respuestas anteriores? - Pedro Mortensen

Esto funciona para mi:

using System;

namespace numberConvert
{
    class Program
    {
        static void Main(string[] args)
        {
            string numberAsString = "8";
            int numberAsInt = int.Parse(numberAsString);
        }
    }
}

Respondido 18 Feb 20, 15:02

Una explicación estaría en orden. - Pedro Mortensen

Puedes probar lo siguiente. Funcionará:

int x = Convert.ToInt32(TextBoxD1.Text);

El valor de la cadena en la variable TextBoxD1.Text se convertirá en Int32 y se almacenará en x.

Respondido 27 Abr '20, 22:04

Todas las respuestas anteriores son buenas, pero como información, podemos usar int.TryParse que es seguro convertir cadena a int, ejemplo

// TryParse returns true if the conversion succeeded
// and stores the result in j.
int j;
if (Int32.TryParse("-105", out j))
   Console.WriteLine(j);
else
   Console.WriteLine("String could not be parsed.");
// Output: -105

TryParse nunca lanza una excepción, incluso en una entrada no válida y nula. En general, es preferible a int.Parse en la mayoría de los contextos de programas.

Fuente: ¿Cómo convertir una cadena a int en C #? (Con diferencia entre Int.Parse e Int. TryParse)

Respondido 06 ago 20, 08:08

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.