Docs executáveis de C#: String para int

Q: Como converter uma string para int em C#?

Use int.TryParse(text, out int number) quando o texto vem de um usuário, de um arquivo ou da rede: ele retorna false em vez de lançar exceção quando o texto não é um número válido. Use int.Parse(text) quando um texto inválido é um bug e uma exceção é a resposta certa. Convert.ToInt32(text) se comporta como int.Parse, exceto que retorna 0 para null.

Q: Qual a diferença entre int.Parse e Convert.ToInt32?

Para strings, eles são quase iguais: os dois lançam FormatException em textos como "abc" e OverflowException em números fora do intervalo. A diferença é o null: int.Parse(null) lança ArgumentNullException, enquanto Convert.ToInt32(null) retorna 0. Convert.ToInt32 também aceita outros tipos (double, bool, object) e arredonda um double para o inteiro par mais próximo em vez de truncar.

Q: O que significa "Input string was not in a correct format"?

É a mensagem de uma FormatException lançada por int.Parse, double.Parse ou Convert.ToInt32 (no .NET 8 em diante ela diz "The input string 'abc' was not in a correct format", citando o texto) quando o texto não é um número no formato esperado: letras, uma string vazia, um ponto decimal ao converter para int, ou um separador de milhar. Troque para TryParse para tratar entradas inválidas sem exceção, e verifique em que cultura o número foi escrito.

Q: Como fazer o cast de um double para int em C#?

Escreva um cast explícito: int n = (int)price;. O cast trunca em direção a zero, então (int)9.99 é 9 e (int)-9.99 é -9. Para arredondar, use (int)Math.Round(price), e lembre que Math.Round arredonda as metades para o par mais próximo por padrão; passe MidpointRounding.AwayFromZero para o arredondamento da escola.

Q: Qual a diferença entre as e um cast em C#?

Um cast (Dog)animal lança InvalidCastException se o objeto não for um Dog. animal as Dog retorna null no lugar, então precisa ser seguido de uma verificação de null, e só funciona com tipos de referência e anuláveis. A alternativa moderna é o padrão is: if (animal is Dog dog) { ... } testa e converte em um passo.

C# nunca converte entre tipos sem relação por conta própria. Uma string que contém dígitos continua sendo uma string, e um double não vira um int em silêncio. Você converte explicitamente, e a ferramenta depende do que você está convertendo: texto para número (parsing), um tipo numérico para outro (cast), ou um objeto para um tipo mais específico (as, is).

String para int: Parse, TryParse e Convert

Há três formas padrão de transformar texto em um int:

using System;

class Program
{
    static void Main()
    {
        string text = "1250";

        int a = int.Parse(text);
        int b = Convert.ToInt32(text);
        Console.WriteLine(a + b);

        if (int.TryParse(text, out int c))
        {
            Console.WriteLine($"TryParse ok: {c}");
        }

        if (!int.TryParse("12 apples", out int d))
        {
            Console.WriteLine($"TryParse failed, d = {d}");
        }

        Console.WriteLine(int.Parse("  42 "));   // surrounding spaces are allowed
        Console.WriteLine(int.Parse("-17"));
    }
}

Saída:

2500
TryParse ok: 1250
TryParse failed, d = 0
42
-17

int.TryParse retorna um bool e escreve o resultado em uma variável out, que recebe 0 em caso de falha. Como entrada inválida é normal em qualquer coisa que um usuário digita, o TryParse é a escolha padrão para entradas, arquivos e query strings. Os mesmos métodos existem em todo tipo numérico: long.TryParse, double.TryParse, decimal.Parse e assim por diante.

O que cada um faz com uma entrada inválida

Os três métodos só diferem na forma como falham:

using System;

class Program
{
    static void Try(string label, Func<int> parse)
    {
        try
        {
            Console.WriteLine($"{label} = {parse()}");
        }
        catch (Exception e)
        {
            Console.WriteLine($"{label} throws {e.GetType().Name}");
        }
    }

    static void Main()
    {
        string empty = null;
        Try("int.Parse(null)", () => int.Parse(empty));
        Try("Convert.ToInt32(null)", () => Convert.ToInt32(empty));
        Try("int.Parse(\"abc\")", () => int.Parse("abc"));
        Try("int.Parse(\"12.5\")", () => int.Parse("12.5"));
        Try("int.Parse(\"1,000\")", () => int.Parse("1,000"));
        Try("int.Parse(\"9999999999\")", () => int.Parse("9999999999"));
        Try("int.Parse(\"\")", () => int.Parse(""));
    }
}

Saída:

int.Parse(null) throws ArgumentNullException
Convert.ToInt32(null) = 0
int.Parse("abc") throws FormatException
int.Parse("12.5") throws FormatException
int.Parse("1,000") throws FormatException
int.Parse("9999999999") throws OverflowException
int.Parse("") throws FormatException

Uma FormatException traz a conhecida mensagem "Input string was not in a correct format" (no .NET 8 em diante, "The input string '12.5' was not in a correct format", citando o texto), e é um dos erros de runtime mais comuns em C#: "12.5" não é um int, e "1,000" também não. Para aceitá-los, converta para decimal, ou diga ao parser quais estilos são permitidos:

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        var inv = CultureInfo.InvariantCulture;

        int withCommas = int.Parse("1,000", NumberStyles.AllowThousands, inv);
        int fromHex = int.Parse("FF", NumberStyles.HexNumber);
        decimal price = decimal.Parse("12.5", inv);
        int rounded = (int)Math.Round(price, MidpointRounding.AwayFromZero);

        Console.WriteLine(withCommas);
        Console.WriteLine(fromHex);
        Console.WriteLine(rounded);
        Console.WriteLine(Convert.ToInt32("1010", 2));  // from binary
    }
}

Saída:

Cultura: por que "1.5" pode virar 15

O parsing usa a cultura atual por padrão, e as culturas discordam sobre os separadores. Em alemão, português do Brasil e várias outras culturas, o separador decimal é a vírgula e o ponto agrupa os milhares. A mesma string dá números diferentes:

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        var german = new CultureInfo("de-DE");
        var inv = CultureInfo.InvariantCulture;

        decimal a = decimal.Parse("1.5", inv);
        decimal b = decimal.Parse("1.5", german);   // "." is a group separator here
        decimal c = decimal.Parse("1,5", german);

        Console.WriteLine(a.ToString(inv));
        Console.WriteLine(b.ToString(inv));
        Console.WriteLine(c.ToString(inv));
    }
}

Saída:

1.5
15
1.5

Código que lê arquivos de dados, JSON, configuração ou qualquer coisa gerada por máquina deve sempre passar CultureInfo.InvariantCulture, tanto ao converter quanto ao formatar. Caso contrário, o mesmo programa funciona na máquina de um desenvolvedor e lê errado todos os números em um servidor configurado em outro idioma. Use a cultura atual só para texto que uma pessoa digitou ou vai ler.

Conversões numéricas implícitas e explícitas

Conversões de ampliação acontecem de forma implícita: int para long, int para double, float para double, int para decimal. Uma conversão que pode perder a magnitude do valor ou a parte fracionária exige um cast explícito (type)value. Uma exceção a lembrar: int ou long para float, e long para double, são implícitas mesmo podendo perder precisão: float f = 16_777_217; compila e guarda 16777216.

using System;

class Program
{
    static void Main()
    {
        int items = 7;
        long bigItems = items;       // implicit: always fits
        double ratio = items;        // implicit
        decimal money = items;       // implicit

        double price = 9.99;
        int whole = (int)price;      // explicit: truncates toward zero
        int negative = (int)-9.99;
        Console.WriteLine($"{whole} {negative}");

        Console.WriteLine(Convert.ToInt32(9.99));   // rounds
        Console.WriteLine(Convert.ToInt32(2.5));    // halves go to even: 2
        Console.WriteLine(Convert.ToInt32(3.5));    // 4

        long large = 5_000_000_000;
        int wrapped = (int)large;    // keeps the low 32 bits
        Console.WriteLine(wrapped);

        decimal amount = (decimal)price;  // double to decimal: explicit
        Console.WriteLine(amount);
        Console.WriteLine($"{bigItems} {ratio:F1} {money}");
    }
}

Saída:

Três coisas para lembrar. Um cast de ponto flutuante para inteiro trunca; ele não arredonda. Convert.ToInt32(double) arredonda, usando o arredondamento bancário (as metades vão para o vizinho par). E um cast inteiro que não cabe dá a volta sem aviso, a menos que execute em um contexto checked, onde lança OverflowException (veja tipos de dados).

int x = 3.7; é um erro de compilação (CS0266: cannot implicitly convert type 'double' to 'int', an explicit conversion exists), que é o compilador pedindo que você escolha entre um cast e um método de arredondamento.

Números e outros tipos para string

Todo tipo tem ToString(), e os tipos numéricos aceitam uma string de formato. A interpolação de strings chama a mesma formatação:

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        int orderId = 42;
        decimal total = 1234.5m;
        var us = new CultureInfo("en-US");

        Console.WriteLine(orderId.ToString());
        Console.WriteLine(orderId.ToString("D6"));        // 000042
        Console.WriteLine(total.ToString("F2"));          // 1234.50
        Console.WriteLine(total.ToString("N2", us));      // 1,234.50
        Console.WriteLine(total.ToString("C", us));       // $1,234.50
        Console.WriteLine(255.ToString("X"));             // FF
        Console.WriteLine(Convert.ToString(10, 2));       // 1010
        Console.WriteLine(true.ToString());
        Console.WriteLine($"Order {orderId:D6}: {total:F2}");
    }
}

Saída:

42
000042
1234.50
1,234.50
$1,234.50
FF
1010
True
Order 000042: 1234.50

Os códigos de formato (D, F, N, C, X, P, E) e os padrões personalizados como "0.00" são cobertos em interpolação de strings.

Caracteres e booleanos

using System;

class Program
{
    static void Main()
    {
        char digit = '7';
        Console.WriteLine(digit);            // the character
        Console.WriteLine((int)digit);       // its code: 55
        Console.WriteLine(digit - '0');      // its value: 7
        Console.WriteLine(char.GetNumericValue(digit));
        Console.WriteLine((char)65);         // A

        Console.WriteLine(bool.Parse("True"));
        Console.WriteLine(bool.Parse("false"));
        Console.WriteLine(Convert.ToInt32(true));
        Console.WriteLine(Convert.ToBoolean(0));
    }
}

Saída:

7
55
7
7
A
True
False
1
False

(int)'7' é 55, o código do caractere, não 7. Isso pega quem soma os dígitos de um número; subtraia '0' ou use char.GetNumericValue. bool.Parse aceita "true" e "false" com qualquer combinação de maiúsculas e minúsculas, e nada mais ("yes" e "1" lançam exceção).

Conversões de referência: casts, as e is

Para tipos de classe, um cast verifica o tipo real do objeto em tempo de execução. O upcast para uma classe base é implícito. O downcast para uma classe derivada precisa de um cast explícito, que lança InvalidCastException quando o objeto é outra coisa:

using System;

class Payment { public decimal Amount = 50m; }
class CardPayment : Payment { public string Last4 = "4242"; }
class CashPayment : Payment { }

class Program
{
    static void Main()
    {
        Payment p = new CardPayment();       // upcast: implicit

        CardPayment card = (CardPayment)p;   // downcast: works, it is a card
        Console.WriteLine(card.Last4);

        Payment cash = new CashPayment();
        CardPayment maybe = cash as CardPayment;  // as: null instead of an exception
        Console.WriteLine(maybe == null);

        if (p is CardPayment c)              // is pattern (C# 7): test and convert
        {
            Console.WriteLine($"Card ending {c.Last4}, {c.Amount:F2}");
        }

        try
        {
            var wrong = (CardPayment)cash;
        }
        catch (InvalidCastException)
        {
            Console.WriteLine("InvalidCastException");
        }

        object boxed = 5;                    // an int boxed as object
        int unboxed = (int)boxed;            // fine
        Console.WriteLine(unboxed);
        try
        {
            long wrongUnbox = (long)boxed;   // must unbox to the exact type
        }
        catch (InvalidCastException)
        {
            Console.WriteLine("cannot unbox int as long");
        }
    }
}

Saída:

4242
True
Card ending 4242, 50.00
InvalidCastException
5
cannot unbox int as long

Prefira is com uma variável quando você precisa ramificar pelo tipo; é uma verificação só, não pode lançar exceção, e a nova variável só existe onde o teste deu certo. Use um cast simples quando um tipo diferente seria um bug que deve falhar de forma visível. O caso do int com boxing pega quem lê números de coleções de object ou de células de DataRow: faça o unboxing para o tipo exato primeiro ((long)(int)boxed), ou use Convert.ToInt64(boxed), que trata qualquer tipo numérico.

Perguntas frequentes

Como converter uma string para int em C#?

Use int.TryParse(text, out int number) quando o texto vem de um usuário, de um arquivo ou da rede: ele retorna false em vez de lançar exceção quando o texto não é um número válido. Use int.Parse(text) quando um texto inválido é um bug e uma exceção é a resposta certa. Convert.ToInt32(text) se comporta como int.Parse, exceto que retorna 0 para null.

Qual a diferença entre int.Parse e Convert.ToInt32?

Para strings, eles são quase iguais: os dois lançam FormatException em textos como "abc" e OverflowException em números fora do intervalo. A diferença é o null: int.Parse(null) lança ArgumentNullException, enquanto Convert.ToInt32(null) retorna 0. Convert.ToInt32 também aceita outros tipos (double, bool, object) e arredonda um double para o inteiro par mais próximo em vez de truncar.

O que significa "Input string was not in a correct format"?

É a mensagem de uma FormatException lançada por int.Parse, double.Parse ou Convert.ToInt32 (no .NET 8 em diante ela diz "The input string 'abc' was not in a correct format", citando o texto) quando o texto não é um número no formato esperado: letras, uma string vazia, um ponto decimal ao converter para int, ou um separador de milhar. Troque para TryParse para tratar entradas inválidas sem exceção, e verifique em que cultura o número foi escrito.

Como fazer o cast de um double para int em C#?

Escreva um cast explícito: int n = (int)price;. O cast trunca em direção a zero, então (int)9.99 é 9 e (int)-9.99 é -9. Para arredondar, use (int)Math.Round(price), e lembre que Math.Round arredonda as metades para o par mais próximo por padrão; passe MidpointRounding.AwayFromZero para o arredondamento da escola.

Qual a diferença entre as e um cast em C#?

Um cast (Dog)animal lança InvalidCastException se o objeto não for um Dog. animal as Dog retorna null no lugar, então precisa ser seguido de uma verificação de null, e só funciona com tipos de referência e anuláveis. A alternativa moderna é o padrão is: if (animal is Dog dog) { ... } testa e converte em um passo.

Conceitos relacionados