Int64.Parse Método

Origem:

Int64.cs

Origem:

Int64.cs

Origem:

Int64.cs

public:
 static long Parse(System::String ^ s);

public static long Parse (string s);

static member Parse : string -> int64

Public Shared Function Parse (s As String) As Long

Parâmetros

Retornos

Um inteiro com sinal de 64 bits equivalente ao número contido em s.

Exceções

Exemplos

O exemplo a seguir demonstra como converter um valor de cadeia de caracteres em um valor inteiro com sinal de 64 bits usando o método Int64.Parse(String). Em seguida, ele exibe o valor inteiro longo resultante.

using System;

public class ParseInt64
{
   public static void Main()
   {
      Convert("  179042  ");
      Convert(" -2041326 ");
      Convert(" +8091522 ");
      Convert("   1064.0   ");
      Convert("  178.3");
      Convert(String.Empty);
      Convert(((decimal) Int64.MaxValue) + 1.ToString());
   }

   private static void Convert(string value)
   {
      try
      {
         long number = Int64.Parse(value);
         Console.WriteLine("Converted '{0}' to {1}.", value, number);
      }
      catch (FormatException)
      {
         Console.WriteLine("Unable to convert '{0}'.", value);
      }
      catch (OverflowException)
      {
         Console.WriteLine("'{0}' is out of range.", value);
      }
   }
}
// This example displays the following output to the console:
//       Converted '  179042  ' to 179042.
//       Converted ' -2041326 ' to -2041326.
//       Converted ' +8091522 ' to 8091522.
//       Unable to convert '   1064.0   '.
//       Unable to convert '  178.3'.
//       Unable to convert ''.
//       '92233720368547758071' is out of range.

open System

let convert value =
    try
        let number = Int64.Parse value
        printfn $"Converted '{value}' to {number}."
    with
    | :? FormatException ->
        printfn $"Unable to convert '{value}'."
    | :? OverflowException ->
        printfn $"'{value}' is out of range."

convert "  179042  "
convert " -2041326 "
convert " +8091522 "
convert "   1064.0   "
convert "  178.3"
convert String.Empty

decimal Int64.MaxValue + 1M
|> string
|> convert

// This example displays the following output to the console:
//       Converted '  179042  ' to 179042.
//       Converted ' -2041326 ' to -2041326.
//       Converted ' +8091522 ' to 8091522.
//       Unable to convert '   1064.0   '.
//       Unable to convert '  178.3'.
//       Unable to convert ''.
//       '92233720368547758071' is out of range.

Module ParseInt64
   Public Sub Main()
      Convert("  179032  ")
      Convert(" -2041326 ")
      Convert(" +8091522 ")
      Convert("   1064.0   ")
      Convert("  178.3")
      Convert(String.Empty)
      Convert((CDec(Int64.MaxValue) + 1).ToString())
   End Sub

   Private Sub Convert(value As String)
      Try
         Dim number As Long = Int64.Parse(value)
         Console.WriteLine("Converted '{0}' to {1}.", value, number)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", value)
      Catch e As OverflowException
         Console.WriteLine("'{0}' is out of range.", value)      
      End Try
   End Sub
End Module
' This example displays the following output to the console:
'       Converted '  179032  ' to 179032.
'       Converted ' -2041326 ' to -2041326.
'       Converted ' +8091522 ' to 8091522.
'       Unable to convert '   1064.0   '.
'       Unable to convert '  178.3'.
'       Unable to convert ''.
'       '9223372036854775808' is out of range.

Comentários

O parâmetro s contém um número do formulário:

[ws] [sign]digits[ws]

Elementos em colchetes ([ e ]) são opcionais. A tabela a seguir descreve cada elemento.

O parâmetro s é interpretado usando o estilo NumberStyles.Integer. Além dos dígitos decimais, somente espaços à esquerda e à direita, juntamente com um sinal à esquerda, são permitidos. Para definir explicitamente os elementos de estilo que podem estar presentes em s, use a Int64.Parse(String, NumberStyles) ou o método Int64.Parse(String, NumberStyles, IFormatProvider).

O parâmetro s é analisado usando as informações de formatação em um objeto NumberFormatInfo inicializado para a cultura atual do sistema. Para analisar uma cadeia de caracteres usando as informações de formatação de alguma outra cultura, use o método Int64.Parse(String, NumberStyles, IFormatProvider).

Confira também

• ToString()
• analisar cadeias de caracteres numéricas no .NET

Origem:

Int64.cs

Origem:

Int64.cs

public:
 static long Parse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider) = IUtf8SpanParsable<long>::Parse;

public static long Parse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider);

static member Parse : ReadOnlySpan<byte> * IFormatProvider -> int64

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider) As Long

Parâmetros

Retornos

O resultado da análise de utf8Text.

Implementações

Origem:

Int64.cs

Origem:

Int64.cs

Origem:

Int64.cs

public:
 static long Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<long>::Parse;

public static long Parse (ReadOnlySpan<char> s, IFormatProvider? provider);

static member Parse : ReadOnlySpan<char> * IFormatProvider -> int64

Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As Long

Parâmetros

Retornos

O resultado da análise de s.

Implementações

Origem:

Int64.cs

Origem:

Int64.cs

Origem:

Int64.cs

public:
 static long Parse(System::String ^ s, System::Globalization::NumberStyles style);

public static long Parse (string s, System.Globalization.NumberStyles style);

static member Parse : string * System.Globalization.NumberStyles -> int64

Public Shared Function Parse (s As String, style As NumberStyles) As Long

Parâmetros

Retornos

Um inteiro com sinal de 64 bits equivalente ao número especificado em s.

Exceções

Exemplos

O exemplo a seguir usa o método Int64.Parse(String, NumberStyles) para analisar as representações de cadeia de caracteres de vários valores Int64. A cultura atual do exemplo é en-US.

using System;
using System.Globalization;

public class ParseInt32
{
   public static void Main()
   {
      Convert("104.0", NumberStyles.AllowDecimalPoint);
      Convert("104.9", NumberStyles.AllowDecimalPoint);
      Convert (" 106034", NumberStyles.None);
      Convert(" $17,198,064.42", NumberStyles.AllowCurrencySymbol |
                                 NumberStyles.Number);
      Convert(" $17,198,064.00", NumberStyles.AllowCurrencySymbol |
                                 NumberStyles.Number);
      Convert("103E06", NumberStyles.AllowExponent);
      Convert("1200E-02", NumberStyles.AllowExponent);
      Convert("1200E-03", NumberStyles.AllowExponent);
      Convert("-1,345,791", NumberStyles.AllowThousands);
      Convert("(1,345,791)", NumberStyles.AllowThousands |
                             NumberStyles.AllowParentheses);
      Convert("FFCA00A0", NumberStyles.HexNumber);
      Convert("0xFFCA00A0", NumberStyles.HexNumber);
   }

   private static void Convert(string value, NumberStyles style)
   {
      try
      {
         long number = Int64.Parse(value, style);
         Console.WriteLine("Converted '{0}' to {1}.", value, number);
      }
      catch (FormatException)
      {
         Console.WriteLine("Unable to convert '{0}'.", value);
      }
      catch (OverflowException)
      {
         Console.WriteLine("'{0}' is out of range of the Int64 type.", value);
      }
   }
}
// The example displays the following output to the console:
//       Converted '104.0' to 104.
//       '104.9' is out of range of the Int64 type.
//       Unable to convert ' 106034'.
//       ' $17,198,064.42' is out of range of the Int64 type.
//       Converted ' $17,198,064.00' to 17198064.
//       Converted '103E06' to 103000000.
//       Converted '1200E-02' to 12.
//       '1200E-03' is out of range of the Int64 type.
//       Unable to convert '-1,345,791'.
//       Converted '(1,345,791)' to -1345791.
//       Converted 'FFCA00A0' to 4291428512.
//       Unable to convert '0xFFCA00A0'.

open System
open System.Globalization

let convert value (style: NumberStyles) =
    try
        let number = Int64.Parse(value, style)
        printfn $"converted '{value}' to {number}." 
    with
    | :? FormatException ->
        printfn $"Unable to convert '{value}'."
    | :? OverflowException ->
        printfn $"'{value}' is out of range of the Int64 type."

convert "104.0" NumberStyles.AllowDecimalPoint
convert "104.9" NumberStyles.AllowDecimalPoint
convert " 106034" NumberStyles.None
convert " $17,198,064.42" (NumberStyles.AllowCurrencySymbol ||| NumberStyles.Number)
convert " $17,198,064.00" (NumberStyles.AllowCurrencySymbol ||| NumberStyles.Number)
convert "103E06" NumberStyles.AllowExponent
convert "1200E-02" NumberStyles.AllowExponent
convert "1200E-03" NumberStyles.AllowExponent
convert "-1,345,791" NumberStyles.AllowThousands
convert "(1,345,791)" (NumberStyles.AllowThousands ||| NumberStyles.AllowParentheses)
convert "FFCA00A0" NumberStyles.HexNumber
convert "0xFFCA00A0" NumberStyles.HexNumber


// The example displays the following output to the console:
//       converted '104.0' to 104.
//       '104.9' is out of range of the Int64 type.
//       Unable to convert ' 106034'.
//       ' $17,198,064.42' is out of range of the Int64 type.
//       converted ' $17,198,064.00' to 17198064.
//       converted '103E06' to 103000000.
//       converted '1200E-02' to 12.
//       '1200E-03' is out of range of the Int64 type.
//       Unable to convert '-1,345,791'.
//       converted '(1,345,791)' to -1345791.
//       converted 'FFCA00A0' to 4291428512.
//       Unable to convert '0xFFCA00A0'.

Imports System.Globalization

Module ParseInt64
   Public Sub Main()
      Convert("104.0", NumberStyles.AllowDecimalPoint)    
      Convert("104.9", NumberStyles.AllowDecimalPoint)
      Convert (" 106034", NumberStyles.None)
      Convert(" $17,198,064.42", NumberStyles.AllowCurrencySymbol Or _
                                 NumberStyles.Number)
      Convert(" $17,198,064.00", NumberStyles.AllowCurrencySymbol Or _
                                 NumberStyles.Number)
      Convert("103E06", NumberStyles.AllowExponent)  
      Convert("1200E-02", NumberStyles.AllowExponent)
      Convert("1200E-03", NumberStyles.AllowExponent)
      Convert("-1,345,791", NumberStyles.AllowThousands)
      Convert("(1,345,791)", NumberStyles.AllowThousands Or _
                             NumberStyles.AllowParentheses)
      Convert("FFCA00A0", NumberStyles.HexNumber)                       
      Convert("0xFFCA00A0", NumberStyles.HexNumber)                       
   End Sub
   
   Private Sub Convert(value As String, style As NumberStyles)
      Try
         Dim number As Long = Int64.Parse(value, style)
         Console.WriteLine("Converted '{0}' to {1}.", value, number)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", value)
      Catch e As OverflowException
         Console.WriteLine("'{0}' is out of range of the Int64 type.", value)   
      End Try
   End Sub
End Module
' The example displays the following output to the console:
'       Converted '104.0' to 104.
'       '104.9' is out of range of the Int64 type.
'       Unable to convert ' 106034'.
'       ' $17,198,064.42' is out of range of the Int64 type.
'       Converted ' $17,198,064.00' to 17198064.
'       Converted '103E06' to 103000000.
'       Converted '1200E-02' to 12.
'       '1200E-03' is out of range of the Int64 type.
'       Unable to convert '-1,345,791'.
'       Converted '(1,345,791)' to -1345791.
'       Converted 'FFCA00A0' to 4291428512.
'       Unable to convert '0xFFCA00A0'.

Comentários

O parâmetro style define os elementos de estilo (como espaço em branco, o símbolo de sinal positivo ou negativo ou o símbolo separador de milhares) que são permitidos no parâmetro s para que a operação de análise tenha êxito. Deve ser uma combinação de sinalizadores de bits da enumeração NumberStyles. Dependendo do valor de style, o parâmetro s pode conter os seguintes elementos:

[ws] [$] [sign] [dígitos,]dígitos[.fractional_digits][e[sign]exponential_digits][ws]

Ou, se style incluir AllowHexSpecifier:

[ws]hexdigits[ws]

Elementos em colchetes ([ e ]) são opcionais. A tabela a seguir descreve cada elemento.

Uma cadeia de caracteres somente com dígitos (que corresponde ao estilo NumberStyles.None) sempre será analisada com êxito se estiver no intervalo do tipo Int64. A maioria dos elementos de controle de membros NumberStyles restantes que podem estar, mas não precisam estar presentes na cadeia de caracteres de entrada. A tabela a seguir indica como membros NumberStyles individuais afetam os elementos que podem estar presentes no s.

Se o sinalizador NumberStyles.AllowHexSpecifier for usado, s deverá ser um valor hexadecimal sem um prefixo. Por exemplo, "C9AF3" analisa com êxito, mas "0xC9AF3" não. Os únicos outros sinalizadores que podem ser combinados com o parâmetro s são NumberStyles.AllowLeadingWhite e NumberStyles.AllowTrailingWhite. (A enumeração NumberStyles inclui um estilo de número composto, NumberStyles.HexNumber, que inclui sinalizadores de espaço em branco.)

O parâmetro s é analisado usando as informações de formatação em um objeto NumberFormatInfo inicializado para a cultura atual do sistema. Para especificar a cultura cujas informações de formatação são usadas para a operação de análise, chame a sobrecarga de Int64.Parse(String, NumberStyles, IFormatProvider).

Confira também

• ToString()
• TryParse
• analisar cadeias de caracteres numéricas no .NET

Origem:

Int64.cs

Origem:

Int64.cs

Origem:

Int64.cs

public:
 static long Parse(System::String ^ s, IFormatProvider ^ provider);

public:
 static long Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<long>::Parse;

public static long Parse (string s, IFormatProvider provider);

public static long Parse (string s, IFormatProvider? provider);

static member Parse : string * IFormatProvider -> int64

Public Shared Function Parse (s As String, provider As IFormatProvider) As Long

Parâmetros

Retornos

Um inteiro com sinal de 64 bits equivalente ao número especificado em s.

Implementações

Exceções

Exemplos

O exemplo a seguir é o manipulador de eventos de clique de botão de um formulário da Web. Ele usa a matriz retornada pela propriedade HttpRequest.UserLanguages para determinar a localidade do usuário. Em seguida, cria uma instância de um objeto CultureInfo que corresponde a essa localidade. O objeto NumberFormatInfo que pertence a esse objeto CultureInfo é passado para o método Parse(String, IFormatProvider) para converter a entrada do usuário em um valor Int64.

protected void OkToLong_Click(object sender, EventArgs e)
{
    string locale;
    long number;
    CultureInfo culture;

    // Return if string is empty
    if (String.IsNullOrEmpty(this.inputNumber.Text))
        return;

    // Get locale of web request to determine possible format of number
    if (Request.UserLanguages.Length == 0)
        return;
    locale = Request.UserLanguages[0];
    if (String.IsNullOrEmpty(locale))
        return;

    // Instantiate CultureInfo object for the user's locale
    culture = new CultureInfo(locale);

    // Convert user input from a string to a number
    try
    {
        number = Int64.Parse(this.inputNumber.Text, culture.NumberFormat);
    }
    catch (FormatException)
    {
        return;
    }
    catch (Exception)
    {
        return;
    }
    // Output number to label on web form
    this.outputNumber.Text = "Number is " + number.ToString();
}

Protected Sub OkToLong_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles OkToLong.Click
   Dim locale As String
   Dim culture As CultureInfo
   Dim number As Long

   ' Return if string is empty
   If String.IsNullOrEmpty(Me.inputNumber.Text) Then Exit Sub

   ' Get locale of web request to determine possible format of number
   If Request.UserLanguages.Length = 0 Then Exit Sub
   locale = Request.UserLanguages(0)
   If String.IsNullOrEmpty(locale) Then Exit Sub

   ' Instantiate CultureInfo object for the user's locale
   culture = New CultureInfo(locale)

   ' Convert user input from a string to a number
   Try
      number = Int64.Parse(Me.inputNumber.Text, culture.NumberFormat)
   Catch ex As FormatException
      Exit Sub
   Catch ex As Exception
      Exit Sub
   End Try

   ' Output number to label on web form
   Me.outputNumber.Text = "Number is " & number.ToString()
End Sub

Comentários

Essa sobrecarga do método Parse(String, IFormatProvider) normalmente é usada para converter texto que pode ser formatado de várias maneiras para um valor Int64. Por exemplo, ele pode ser usado para converter o texto inserido por um usuário em uma caixa de texto HTML em um valor numérico.

O parâmetro s contém um número do formulário:

[ws] [sign]digits[ws]

Itens em colchetes ([ e ]) são opcionais, e outros itens são os seguintes.

ws Um espaço em branco opcional.

assinar um sinal opcional.

dígitos Uma sequência de dígitos variando de 0 a 9.

O parâmetro s é interpretado usando o estilo NumberStyles.Integer. Além dos dígitos decimais, somente espaços à esquerda e à direita, juntamente com um sinal à esquerda, são permitidos. Para definir explicitamente os elementos de estilo que podem estar presentes em s, use o método Int64.Parse(String, NumberStyles, IFormatProvider).

O parâmetro provider é uma implementação IFormatProvider, como um objeto NumberFormatInfo ou CultureInfo. O parâmetro provider fornece informações específicas da cultura sobre o formato de s. Se provider for null, o NumberFormatInfo da cultura atual será usado.

Confira também

• ToString()
• TryParse
• analisar cadeias de caracteres numéricas no .NET

Origem:

Int64.cs

Origem:

Int64.cs

public static long Parse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);

static member Parse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider -> int64

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As Long

Parâmetros

Retornos

O resultado da análise de utf8Text.

Implementações

Origem:

Int64.cs

Origem:

Int64.cs

Origem:

Int64.cs

public static long Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);

public static long Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider provider = default);

static member Parse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider -> int64

Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As Long

Parâmetros

Retornos

Um inteiro com sinal de 64 bits equivalente ao número especificado em s.

Implementações

Origem:

Int64.cs

Origem:

Int64.cs

Origem:

Int64.cs

public:
 static long Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider);

public:
 static long Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<long>::Parse;

public static long Parse (string s, System.Globalization.NumberStyles style, IFormatProvider provider);

public static long Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);

static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> int64

Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As Long

Parâmetros

Retornos

Um inteiro com sinal de 64 bits equivalente ao número especificado em s.

Implementações

Exceções

Exemplos

O exemplo a seguir usa uma variedade de parâmetros style e provider para analisar as representações de cadeia de caracteres de valores Int64. Ele também ilustra algumas das diferentes maneiras pelas quais a mesma cadeia de caracteres pode ser interpretada dependendo da cultura cujas informações de formatação são usadas para a operação de análise.

using System;
using System.Globalization;

public class ParseInt64
{
   public static void Main()
   {
      Convert("12,000", NumberStyles.Float | NumberStyles.AllowThousands,
              new CultureInfo("en-GB"));
      Convert("12,000", NumberStyles.Float | NumberStyles.AllowThousands,
              new CultureInfo("fr-FR"));
      Convert("12,000", NumberStyles.Float, new CultureInfo("en-US"));

      Convert("12 425,00", NumberStyles.Float | NumberStyles.AllowThousands,
              new CultureInfo("sv-SE"));
      Convert("12,425.00", NumberStyles.Float | NumberStyles.AllowThousands,
              NumberFormatInfo.InvariantInfo);
      Convert("631,900", NumberStyles.Integer | NumberStyles.AllowDecimalPoint,
              new CultureInfo("fr-FR"));
      Convert("631,900", NumberStyles.Integer | NumberStyles.AllowDecimalPoint,
              new CultureInfo("en-US"));
      Convert("631,900", NumberStyles.Integer | NumberStyles.AllowThousands,
              new CultureInfo("en-US"));
   }

   private static void Convert(string value, NumberStyles style,
                               IFormatProvider provider)
   {
      try
      {
         long number = Int64.Parse(value, style, provider);
         Console.WriteLine("Converted '{0}' to {1}.", value, number);
      }
      catch (FormatException)
      {
         Console.WriteLine("Unable to convert '{0}'.", value);
      }
      catch (OverflowException)
      {
         Console.WriteLine("'{0}' is out of range of the Int64 type.", value);
      }
   }
}
// This example displays the following output to the console:
//       Converted '12,000' to 12000.
//       Converted '12,000' to 12.
//       Unable to convert '12,000'.
//       Converted '12 425,00' to 12425.
//       Converted '12,425.00' to 12425.
//       '631,900' is out of range of the Int64 type.
//       Unable to convert '631,900'.
//       Converted '631,900' to 631900.

open System
open System.Globalization

let convert (value: string) style provider =
    try
        let number = Int64.Parse(value, style, provider)
        printfn $"Converted '{value}' to {number}."
    with
    | :? FormatException ->
        printfn $"Unable to convert '{value}'."
    | :? OverflowException ->
        printfn $"'{value}' is out of range of the Int64 type."

convert "12,000" (NumberStyles.Float ||| NumberStyles.AllowThousands) (CultureInfo "en-GB")
convert "12,000" (NumberStyles.Float ||| NumberStyles.AllowThousands) (CultureInfo "fr-FR")
convert "12,000" NumberStyles.Float (CultureInfo "en-US")
convert "12 425,00" (NumberStyles.Float ||| NumberStyles.AllowThousands) (CultureInfo "sv-SE")
convert "12,425.00" (NumberStyles.Float ||| NumberStyles.AllowThousands) NumberFormatInfo.InvariantInfo
convert "631,900" (NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint) (CultureInfo "fr-FR")
convert "631,900" (NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint) (CultureInfo "en-US")
convert "631,900" (NumberStyles.Integer ||| NumberStyles.AllowThousands) (CultureInfo "en-US")

// This example displays the following output to the console:
//       Converted '12,000' to 12000.
//       Converted '12,000' to 12.
//       Unable to convert '12,000'.
//       Converted '12 425,00' to 12425.
//       Converted '12,425.00' to 12425.
//       '631,900' is out of range of the Int64 type.
//       Unable to convert '631,900'.
//       Converted '631,900' to 631900.

Imports System.Globalization

Module ParseInt64
   Public Sub Main()
      Convert("12,000", NumberStyles.Float Or NumberStyles.AllowThousands, _
              New CultureInfo("en-GB"))      
      Convert("12,000", NumberStyles.Float Or NumberStyles.AllowThousands, _
              New CultureInfo("fr-FR"))
      Convert("12,000", NumberStyles.Float, New CultureInfo("en-US"))
      
      Convert("12 425,00", NumberStyles.Float Or NumberStyles.AllowThousands, _
              New CultureInfo("sv-SE")) 
      Convert("12,425.00", NumberStyles.Float Or NumberStyles.AllowThousands, _
              NumberFormatInfo.InvariantInfo) 
      Convert("631,900", NumberStyles.Integer Or NumberStyles.AllowDecimalPoint, _ 
              New CultureInfo("fr-FR"))
      Convert("631,900", NumberStyles.Integer Or NumberStyles.AllowDecimalPoint, _
              New CultureInfo("en-US"))
      Convert("631,900", NumberStyles.Integer Or NumberStyles.AllowThousands, _
              New CultureInfo("en-US"))
   End Sub

   Private Sub Convert(value As String, style As NumberStyles, _
                       provider As IFormatProvider)
      Try
         Dim number As Long = Int64.Parse(value, style, provider)
         Console.WriteLine("Converted '{0}' to {1}.", value, number)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", value)
      Catch e As OverflowException
         Console.WriteLine("'{0}' is out of range of the Int64 type.", value)   
      End Try
   End Sub                       
End Module
' This example displays the following output to the console:
'       Converted '12,000' to 12000.
'       Converted '12,000' to 12.
'       Unable to convert '12,000'.
'       Converted '12 425,00' to 12425.
'       Converted '12,425.00' to 12425.
'       '631,900' is out of range of the Int64 type.
'       Unable to convert '631,900'.
'       Converted '631,900' to 631900.

Comentários

O parâmetro style define os elementos de estilo (como espaço em branco ou o sinal positivo) que são permitidos no parâmetro s para que a operação de análise tenha êxito. Deve ser uma combinação de sinalizadores de bits da enumeração NumberStyles. Dependendo do valor de style, o parâmetro s pode incluir os seguintes elementos:

[ws] [$] [sign] [dígitos,]dígitos[.fractional_digits][e[sign]exponential_digits][ws]

Ou, se style incluir AllowHexSpecifier:

[ws]hexdigits[ws]

Elementos em colchetes ([ e ]) são opcionais. A tabela a seguir descreve cada elemento.

Uma cadeia de caracteres somente com dígitos decimais (que corresponde ao estilo NumberStyles.None) sempre será analisada com êxito se estiver no intervalo do tipo Int64. A maioria dos elementos de controle de membros NumberStyles restantes que podem estar, mas não precisam estar presentes nesta cadeia de caracteres de entrada. A tabela a seguir indica como membros NumberStyles individuais afetam os elementos que podem estar presentes no s.

Se o sinalizador NumberStyles.AllowHexSpecifier for usado, s deverá ser um valor hexadecimal sem um prefixo. Por exemplo, "C9AF3" analisa com êxito, mas "0xC9AF3" não. Os únicos outros sinalizadores que podem estar presentes em style são NumberStyles.AllowLeadingWhite e NumberStyles.AllowTrailingWhite. (A enumeração NumberStyles tem um estilo de número composto, NumberStyles.HexNumber, que inclui sinalizadores de espaço em branco.)

O parâmetro provider é uma implementação IFormatProvider, como um objeto NumberFormatInfo ou CultureInfo. O parâmetro provider fornece informações específicas da cultura usadas na análise. Se provider for null, o NumberFormatInfo da cultura atual será usado.

Confira também

• ToString()
• analisar cadeias de caracteres numéricas no .NET