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:
- int.Parse() – lança uma exceção se a conversão falhar
- 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.