No artigo de hoje vou mostrar as diferenças entre int.Parse() e int.TryParse().

Os métodos int.Parse() e int.TryParse() são usados para converter uma representação de string de um número em um inteiro. Simples assim.

Sintaxe:

Parse()	TryParse()
public static int Parse(string s )	public static bool TryParse(string s,out int result )

Onde:

• s: representação da string a ser convertida para inteiro
• result: contém o valor inteiro convertido

Segundo a documentação, se a conversão falhar, o tratamento é feito assim:

1. int.Parse() – lança uma exceção se a conversão falhar
2. int.TryParse() – Se a conversão falhar, retorna zero

As exceções possíveis usando ambos os métodos, são:

Exceção	Condição
ArgumentNullException	s é null.
FormatException	s não esta em um formato válido
OverflowException	s esta fora da faixa dos números inteiros

O método TryParse é igual ao método Parse, exceto pelo fato de que o método TryParse não lança uma exceção se a conversão falhar. Assim ele elimina a necessidade de usar o tratamento de exceções para testar uma FormatException no caso em que s seja inválido e não possa ser analisado com sucesso.

Vamos analisar um exemplo usando int.Parse():

Conversão para int usando Int.Parse()	Resultado
string valor1 = “100” int valor2 = int.Parse(valor1);	O valor é convertido sem erros. valor2 = 100
string valor1 =null; int valor2 = int.Parse(valor1);	Lança a exceção ArgumentNullException
string valor1 = “100.99”; int valor2 = int.Parse(valor1);	Lança a exceção FormatException
string valor1 = “999999999999999999999999999999”; int valor2 = int.Parse(valor1);	Lança a exceção OverflowException

Vamos analisar um exemplo usando int.TryParse():

Conversão para int usando Int.TryParse()	Resultado
string valor1 = “100” int resultado; bool sucesso = int.Parse(valor1, out resultado);	O valor é convertido sem erros. resultado = 1000 e sucesso = true
string valor1 = null; int resultado; bool sucesso = int.Parse(valor1, out resultado);	Conversão falhou resultado = 0 e sucesso = false
string valor1 = “100.99”string valor1 = “100.99”int resultado;bool sucesso = int.Parse(valor1, out resultado);	Conversão falhou resultado = 0 e sucesso = false
string valor1 = “999999999999999999999”string valor1 = “999999999999999999999”int resultado;bool sucesso = int.Parse(valor1, out resultado);	Conversão falhou resultado = 0 e sucesso = false

Qual o melhor método?

A princípio, TryParse(), visto que ele elimina a necessidade do tratamento de exceção para testar um FormatException no caso do valor a ser convertido ser inválido. Exemplo:

static void usandoTryParse()
        {
            String[] valores = { null, "160519", "9432.0", "16,667","-322", "+4302", "(100);", "01FA" };
            foreach (var valor in valores)
            {
                int numero;
                bool resultado = Int32.TryParse(valor, out numero);
                if (resultado)
                {
                    Console.WriteLine("Conversão de '{0}' para {1}.", valor, numero);
                }
                else
                {
                    Console.WriteLine("A conversão de '{0}' Falhou.",valor == null ? "<null>" : valor);
                }
            }
            Console.ReadLine();
        }

Agora, se você precisar saber porque e quando a conversão falhou, talvez o método Parse() seja mais indicado. Veja o exemplo usando esta abordagem:

using System;
namespace CShp_TryParse
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] valores = { "+13230", "-0", "1,390,146", "$190,235,421,127",
                                "0xFA1B", "163042", "-10", "007", "2147483647",
                                "2147483648", "16e07", "134985.0", "-12034",
                                "-2147483648", "-2147483649", null };
            foreach (string valor in valores)
            {
                try
                {
                    int numero = Int32.Parse(valor);
                    Console.WriteLine("{0} --> {1}", valor, numero);
                }
                catch (FormatException)
                {
                    Console.WriteLine("{0}: Formato Inválido", valor);
                }
                catch (OverflowException)
                {
                    Console.WriteLine("{0}: Overflow", valor);
                }
                catch (ArgumentNullException)
                {
                    Console.WriteLine("{0}: Valor null", valor);
                }
            }
        }
    }
}

E estamos conversados.