Como: converter uma cadeia de caracteres em um número (Guia de Programação em C#)How to: Convert a String to a Number (C# Programming Guide)

É possível converter uma cadeia de caracteres em um número chamando o método Parse ou TryParse encontrado nos diversos tipos numéricos (int, long, double etc.) ou usando os métodos na classe System.Convert.You can convert a string to a number by calling the Parse or TryParse method found on the various numeric types (int, long, double, etc.), or by using methods in the System.Convert class.

Caso haja uma cadeia de caracteres, será um pouco mais eficiente e simples chamar um método TryParse (por exemplo, int.TryParse("11", out number)) ou o método Parse (por exemplo, var number = int.Parse("11")).If you have a string, it is slightly more efficient and straightforward to call a TryParse method (for example, int.TryParse("11", out number)) or Parse method (for example, var number = int.Parse("11")). Usar um método Convert é mais útil para objetos gerais que implementam IConvertible.Using a Convert method is more useful for general objects that implement IConvertible.

É possível usar métodos Parse ou TryParse no tipo numérico que se espera que a cadeia de caracteres contenha, como o tipo System.Int32.You can use Parse or TryParse methods on the numeric type you expect the string contains, such as the System.Int32 type. O método Convert.ToInt32 usa Parse internamente.The Convert.ToInt32 method uses Parse internally. O método Parse retorna o número convertido; o método TryParse retorna um valor Boolean que indica se a conversão foi bem-sucedida e retorna o número convertido em um parâmetro out.The Parse method returns the converted number; the TryParse method returns a Boolean value that indicates whether the conversion succeeded, and returns the converted number in an out parameter. Se a cadeia de caracteres não estiver em um formato válido, Parse lançará uma exceção, ao passo que TryParse retornará false.If the string is not in a valid format, Parse throws an exception, whereas TryParse returns false. Ao chamar um método Parse, você sempre deve usar o tratamento de exceções para capturar um FormatException no caso da operação de análise falhar.When calling a Parse method, you should always use exception handling to catch a FormatException in the event that the parse operation fails.

Como chamar os métodos Parse e TryParseCalling the Parse and TryParse methods

Os métodos Parse e TryParse ignoram o espaço em branco no início e no final da cadeia de caracteres; porém, todos os outros caracteres devem formar o tipo numérico correto (int, long, ulong, float, decimal etc.).The Parse and TryParse methods ignore white space at the beginning and at the end of the string, but all other characters must be characters that form the appropriate numeric type (int, long, ulong, float, decimal, etc.). Qualquer espaço em branco na cadeia de caracteres que forma o número causa um erro.Any white space within the string that forms the number causes an error. Por exemplo, é possível usar decimal.TryParse para analisar "10", "10,3" ou " 10 ", mas não é possível usar esse método para analisar 10 de "10X", "1 0" (observe o espaço inserido), "10 .3" (observe o espaço inserido), "10e1" (float.TryParse funcionará neste caso) e assim por diante.For example, you can use decimal.TryParse to parse "10", "10.3", or " 10 ", but you cannot use this method to parse 10 from "10X", "1 0" (note the embedded space), "10 .3" (note the embedded space), "10e1" (float.TryParse works here), and so on. Além disso, uma cadeia de caracteres cujo valor seja null ou String.Empty falhará ao ser analisada com êxito.In addition, a string whose value is null or String.Empty fails to parse successfully. Você pode verificar uma cadeia de caracteres nula ou vazia antes de tentar analisá-la chamando o método String.IsNullOrEmpty.You can check for a null or empty string before attempting to parse it by calling the String.IsNullOrEmpty method.

O exemplo a seguir demonstra chamadas com e sem êxito para Parse e TryParse.The following example demonstrates both successful and unsuccessful calls to Parse and TryParse.

using System;

public class StringConversion
{
    public static void Main()
    {
       string input = String.Empty;
       try
       {
           int result = Int32.Parse(input);
           Console.WriteLine(result);
       }
       catch (FormatException)
       {
           Console.WriteLine($"Unable to parse '{input}'");
       }
       // Output: Unable to parse ''

       try
       {
            int numVal = Int32.Parse("-105");
            Console.WriteLine(numVal);
       }
       catch (FormatException e)
       {
           Console.WriteLine(e.Message);
       }
       // Output: -105

        if (Int32.TryParse("-105", out int j))
            Console.WriteLine(j);
        else
            Console.WriteLine("String could not be parsed.");
        // Output: -105

        try
        {
            int m = Int32.Parse("abc");
        }
        catch (FormatException e)
        {
            Console.WriteLine(e.Message);
        }
        // Output: Input string was not in a correct format.

        string inputString = "abc";
        if (Int32.TryParse(inputString, out int numValue))
            Console.WriteLine(inputString);
        else
            Console.WriteLine($"Int32.TryParse could not parse '{inputString}' to an int.");
        // Output: Int32.TryParse could not parse 'abc' to an int.
     }
}

O exemplo a seguir ilustra uma abordagem para analisar uma cadeia de caracteres que deve incluir caracteres numéricos à esquerda (incluindo caracteres hexadecimais) e caracteres não numéricos à direita.The following example illustrates one a approach to parsing a string that is expected to include leading numeric characters (including hexadecimal characters) and trailing non-numeric characters. Ele atribui caracteres válidos do início de uma cadeia de caracteres até uma nova cadeia de caracteres antes de chamar o método TryParse.It assigns valid characters from the beginning of a string to a new string before calling the TryParse method. Como as cadeias de caracteres a ser analisadas contêm um pequeno número de caracteres, o exemplo chama o método String.Concat para atribuir os caracteres válidos em uma nova cadeia de caracteres.Because the strings to be parsed contain a small number of characters, the example calls the String.Concat method to assign valid characters to a new string. Para cadeias de caracteres maiores, pode ser usada a classe StringBuilder.For a larger string, the StringBuilder class can be used instead.

using System;

public class StringConversion
{
    public static void Main()
    {
        var str = "  10FFxxx";
        string numericString = String.Empty;
        foreach (var c in str) 
        {
            // Check for numeric characters (hex in this case) or leading or trailing spaces.
            if ((c >= '0' && c <= '9') || (Char.ToUpperInvariant(c) >= 'A' && Char.ToUpperInvariant(c) <= 'F') || c == ' ') {
                numericString = String.Concat(numericString, c.ToString());
            }
            else
            {
                break;
            }
        }
        if (int.TryParse(numericString, System.Globalization.NumberStyles.HexNumber, null, out int i))
            Console.WriteLine($"'{str}' --> '{numericString}' --> {i}");
            // Output: '  10FFxxx' --> '  10FF' --> 4351

        str = "   -10FFXXX";
        numericString = "";
        foreach (char c in str) {
            // Check for numeric characters (0-9), a negative sign, or leading or trailing spaces.
            if ((c >= '0' && c <= '9') || c == ' ' || c == '-') 
            {
                numericString = String.Concat(numericString, c);
            } else
                break;
        }
        if (int.TryParse(numericString, out int j))
            Console.WriteLine($"'{str}' --> '{numericString}' --> {j}");
            // Output: '   -10FFXXX' --> '   -10' --> -10
    }
}

Chamar os métodos de conversãoCalling the Convert methods

A tabela a seguir lista alguns dos métodos da classe Convert que podem ser usados para converter uma cadeia de caracteres em um número.The following table lists some of the methods from the Convert class that you can use to convert a string to a number.

Tipo numéricoNumeric Type MétodoMethod
decimal ToDecimal(String)
float ToSingle(String)
double ToDouble(String)
short ToInt16(String)
int ToInt32(String)
long ToInt64(String)
ushort ToUInt16(String)
uint ToUInt32(String)
ulong ToUInt64(String)

O exemplo a seguir chama o método Convert.ToInt32(String) para converter uma cadeia de caracteres de entrada em um int. O exemplo captura as duas exceções mais comuns que podem ser geradas por esse método, FormatException e OverflowException.The following example calls the Convert.ToInt32(String) method to convert an input string to an int. The example catches the two most common exceptions that can be thrown by this method, FormatException and OverflowException. Se o número resultante puder ser incrementado sem exceder Int32.MaxValue, o exemplo adicionará 1 ao resultado e exibirá a saída.If the resulting number can be incremented without exceeding Int32.MaxValue, the example adds 1 to the result and displays the output.

using System;

public class ConvertStringExample1
{
    static void Main(string[] args)
    {
        int numVal = -1;
        bool repeat = true;

        while (repeat)
        {
            Console.Write("Enter a number between −2,147,483,648 and +2,147,483,647 (inclusive): ");

            string input = Console.ReadLine();

            // ToInt32 can throw FormatException or OverflowException.
            try
            {
                numVal = Convert.ToInt32(input);
                if (numVal < Int32.MaxValue)
                {
                    Console.WriteLine("The new value is {0}", ++numVal);
                }
                else
                {
                    Console.WriteLine("numVal cannot be incremented beyond its current value");
                }
           }
            catch (FormatException)
            {
                Console.WriteLine("Input string is not a sequence of digits.");
            }
            catch (OverflowException)
            {
                Console.WriteLine("The number cannot fit in an Int32.");
            }

            Console.Write("Go again? Y/N: ");
            string go = Console.ReadLine();
            if (go.ToUpper() != "Y")
            {
                repeat = false;
            }
        }
    }
}
// Sample Output:
//   Enter a number between -2,147,483,648 and +2,147,483,647 (inclusive): 473
//   The new value is 474
//   Go again? Y/N: y
//   Enter a number between -2,147,483,648 and +2,147,483,647 (inclusive): 2147483647
//   numVal cannot be incremented beyond its current value
//   Go again? Y/N: y
//   Enter a number between -2,147,483,648 and +2,147,483,647 (inclusive): -1000
//   The new value is -999
//   Go again? Y/N: n

Consulte tambémSee also