¿Cómo puedo convertir String a Int?

Respuestas:

1039

Prueba esto:

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

o mejor aún:

int x = 0;

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

Además, dado que Int32.TryParsedevuelve un boolpuede 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 tienes curiosidad, la diferencia entre Parsey TryParsese resume mejor así:

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

Andrew Hare
fuente
3
¿Qué sucede si el entero es de 64 bits o se ve como "aslkdlksadjsd"? ¿Esto todavía es seguro?
Jonny
66
@ Jonny Int64.Parse(). Si la entrada no es int, obtendrá una ejecución y un seguimiento de la pila con Int64.Parse, o el booleano Falsecon Int64.TryParse(), por lo que necesitaría una instrucción if, como if (Int32.TryParse(TextBoxD1.Text, out x)) {}.
1
También podría 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 enviar el
55
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 lanzamiento es exitoso. Es decir, en este caso, x = 0 si la cadena tiene caracteres no enteros, o x = valor de cadena como entero de lo 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 por encima de la línea con 'else {// la cadena analizada no es un número entero, por lo tanto, algún código para manejar esta situación}'
Will Croxford
@Roberto está bien, pero es posible que el usuario (ya sea por error o intencionalmente) escriba tal valor "aslkdlksadjsd" dentro de un cuadro de texto. Entonces, ¿debería fallar nuestro programa?
S.Serpooshan
55
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 usar. Int32.TryParsetambién devuelve un valor booleano que indica si se pudo analizar o no, por lo que incluso puede usarlo como condición de una ifinstrucción.

if( Int32.TryParse( TextBoxD1.Text, out val ){
  DoSomething(..);
} else {
  HandleBadInput(..);
}
Babak Naffas
fuente
-1 RE. "Esto le proporcionará un valor predeterminado que puede usar". Si te refieres a val, espera problemas: "Este parámetro se pasa sin inicializar; cualquier valor originalmente proporcionado en el resultado se sobrescribirá". [Árbitro. docs.microsoft.com/en-us/dotnet/api/… ]
Zeek2
66
Hace 10 años me disculpo.
Babak Naffas
37
int.TryParse()

No se lanzará si el texto no es numérico.

n8wrl
fuente
Esto es mejor que los otros dos. Es probable que la entrada del usuario tenga el formato incorrecto. Este es más eficiente que usar el manejo de excepciones como requieren los demás.
UncleO
Exactamente. Devuelve falso si la conversión falló.
n8wrl
21
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.

Andre Kraemer
fuente
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, out NumericJL); if (isNum) // El JL retirado puede pasarse a int luego continuar para la comparación {if (! (NumericJL> = 6)) {// Nominate} // else {}}
baymax
16

Debe analizar la cadena y también debe asegurarse de que realmente esté en el formato de un entero.

La forma más fácil es esta:

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
}
Jacob
fuente
14

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

Si accede a la cadena solo en una determinada posición utilizando el [i]operador de indexación, devolverá ay charno a string.

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

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

int x = Convert.ToInt32(input[indexOfSeven].toString());  // Returns 7
Mong Zhu
fuente
11
int x = 0;
int.TryParse(TextBoxD1.Text, out x);

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

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

jorelli
fuente
11

Disfrútala...

int i = 0;
string s = "123";
i =int.Parse(s);
i = Convert.ToInt32(s);
Salim Latif Waigaonkar
fuente
10

Si bien ya hay muchas soluciones aquí que describen int.Parse, hay algo importante que falta en todas las respuestas. Típicamente, 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 grupo (o miles) y separadores decimales varían según la cultura.

Si desea crear una forma robusta de analizar una cadena a un entero, es importante tener en cuenta la información cultural. Si no lo hace, se usará la configuración de cultura actual . Eso podría dar al usuario una sorpresa bastante desagradable, o incluso peor, si está analizando formatos de archivo. Si solo desea analizar el inglés, lo mejor es hacerlo explícito, especificando la configuración de la cultura a 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 en CultureInfo, específicamente NumberFormatInfo en MSDN.

atlaste
fuente
8

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 donde sea en el código solo llame

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();
Miroslav Holec
fuente
¿No debería llamarse a la clase en StringExtensionslugar de IntegerExtensions, ya que estos métodos de extensión actúan sobre un stringy no sobre un int?
Shiva
7

Como se explica en la 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
}
JeffH
fuente
7
int x = Int32.TryParse(TextBoxD1.Text, out x) ? x : 0;
Mohammad Rahman
fuente
Conciso y proporciona por defecto 👍
Zeek2
6

Puedes usar cualquiera,

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

o

int i = int.Parse(TextBoxD1.Text);
Punto muerto
fuente
¿Cómo es esto diferente de las respuestas anteriores?
Peter Mortensen
5
//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;
}
Jsprings
fuente
El incumplimiento en este caso no sería una buena idea. Si se requiere un incumplimiento por completo, recomiendo devolver 0.
Prageeth Saravanan
5

Puede convertir una cadena a int en C # usando:

Funciones de convertir clase Convert.ToInt16(), es decir Convert.ToInt32(), Convert.ToInt64()o mediante el uso de Parsey TryParseFunciones. Aquí se dan ejemplos .

Atif
fuente
¿Cómo es esto diferente de las respuestas anteriores?
Peter Mortensen
4

También puede usar 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 así:

  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 también pueda analizarlo para duplicar, flotar, etc., puede hacer una extensión genérica.

Misha Zaslavsky
fuente
4

La conversión de stringa intpuede hacerse para: int, Int32, Int64y otros tipos de datos que refleja los tipos de datos enteros en .NET

El siguiente ejemplo muestra esta conversión:

Este elemento del adaptador de datos show (para información) se inicializó en el 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 .

Edwin b
fuente
4

Puede hacer lo siguiente a continuación sin TryParse o funciones incorporadas:

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;
}
lazydeveloper
fuente
convertToInt ("1234") da 10000 ...... si vas a copiar la respuesta de otra persona, al menos copia todo
SerenityNow
no me compares contigo mismo ... agrega una solución actualizada en su lugar ... lol
lazydeveloper
@SerenityNow puedes comprobar ahora. Fue un error tipográfico.
lazydeveloper
1
refiriéndose a su identificación, ¡un desarrollador perezoso no creará tal método! ; D bueno
S.Serpooshan
3
int i = Convert.ToInt32(TextBoxD1.Text);
deepu
fuente
Una explicación estaría en orden. Por ejemplo, ¿en qué se diferencia de la respuesta de Babak Naffas ?
Peter Mortensen
2

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

P.ej:

int val = Int32.parse(stringToBeParsed);
int x = Int32.parse(1234);
Codemaker
fuente
¿Cómo es esto diferente de las respuestas anteriores?
Peter Mortensen
2

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.

Isaac Newton
fuente
0

Si está buscando el camino 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;
    }
grifos de julio
fuente
0

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");
}
Bill Moore
fuente
0

Este código funciona para mí en Visual Studio 2010:

int someValue = Convert.ToInt32(TextBoxD1.Text);
Sarib Shamim
fuente
Sí, pero ¿en qué se diferencia de las respuestas anteriores?
Peter Mortensen
0

Esto funciona para mi:

using System;

namespace numberConvert
{
    class Program
    {
        static void Main(string[] args)
        {
            string numberAsString = "8";
            int numberAsInt = int.Parse(numberAsString);
        }
    }
}
Sheridan Irvine
fuente
Una explicación estaría en orden.
Peter Mortensen
0

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.

Kartikey Kushwaha
fuente
0

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

int.TryParse(TextBoxD1.Text, out int x);
Max Miller
fuente
¿No outse desalientan los parámetros en C # ahora?
Peter Mortensen
-3

Esto puede ayudarte; D

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

        float Stukprijs;
        float Aantal;
        private void label2_Click(object sender, EventArgs e)
        {

        }

        private void button2_Click(object sender, EventArgs e)
        {
            MessageBox.Show("In de eersre textbox staat een geldbedrag." + Environment.NewLine + "In de tweede textbox staat een aantal." + Environment.NewLine + "Bereken wat er moetworden betaald." + Environment.NewLine + "Je krijgt 15% korting over het bedrag BOVEN de 100." + Environment.NewLine + "Als de korting meer dan 10 euri is," + Environment.NewLine + "wordt de korting textbox lichtgroen");
        }

        private void button1_Click(object sender, EventArgs e)
        {
            errorProvider1.Clear();
            errorProvider2.Clear();
            if (float.TryParse(textBox1.Text, out Stukprijs))
            {
                if (float.TryParse(textBox2.Text, out Aantal))
                {
                    float Totaal = Stukprijs * Aantal;
                    string Output = Totaal.ToString();
                    textBox3.Text = Output;
                    if (Totaal >= 100)
                    {
                        float korting = Totaal - 100;
                        float korting2 = korting / 100 * 15;
                        string Output2 = korting2.ToString();
                        textBox4.Text = Output2;
                        if (korting2 >= 10)
                        {
                            textBox4.BackColor = Color.LightGreen;
                        }
                        else
                        {
                            textBox4.BackColor = SystemColors.Control;
                        }
                    }
                    else
                    {
                        textBox4.Text = "0";
                        textBox4.BackColor = SystemColors.Control;
                    }
                }
                else
                {
                    errorProvider2.SetError(textBox2, "Aantal plz!");
                }

            }
            else
            {
                errorProvider1.SetError(textBox1, "Bedrag plz!");
                if (float.TryParse(textBox2.Text, out Aantal))
                {

                }
                else
                {
                    errorProvider2.SetError(textBox2, "Aantal plz!");
                }
            }

        }

        private void BTNwissel_Click(object sender, EventArgs e)
        {
            //LL, LU, LR, LD.
            Color c = LL.BackColor;
            LL.BackColor = LU.BackColor;
            LU.BackColor = LR.BackColor;
            LR.BackColor = LD.BackColor;
            LD.BackColor = c;
        }

        private void button3_Click(object sender, EventArgs e)
        {
            MessageBox.Show("zorg dat de kleuren linksom wisselen als je op de knop drukt.");
        }
    }
}
Jan Koekepan
fuente
Una explicación estaría en orden.
Peter Mortensen