UInt16.Parse Método

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Converte a representação de cadeia de caracteres de um número em seu equivalente inteiro sem sinal de 16 bits.

Sobrecargas

Parse(String, NumberStyles, IFormatProvider)	Converte a representação de cadeia de caracteres de um número em um formato específico de cultura e estilo especificado em seu inteiro sem sinal de 16 bits equivalente.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Converte a representação de intervalo de um número em um formato específico de cultura e estilo especificado em seu inteiro sem sinal de 16 bits equivalente.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analisa um intervalo de caracteres UTF-8 em um valor.
Parse(String, IFormatProvider)	Converte a representação de cadeia de caracteres de um número em um formato específico à cultura especificado em seu inteiro sem sinal de 16 bits equivalente.
Parse(String, NumberStyles)	Converte a representação de cadeia de caracteres de um número em um estilo especificado em seu inteiro sem sinal de 16 bits equivalente. Esse método não é compatível com CLS. A alternativa compatível com CLS é Parse(String, NumberStyles).
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analisa um intervalo de caracteres em um valor.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analisa um intervalo de caracteres UTF-8 em um valor.
Parse(String)	Converte a representação de cadeia de caracteres de um número em seu equivalente inteiro sem sinal de 16 bits.

Parse(String, NumberStyles, IFormatProvider)

Origem:

UInt16.cs

Importante

Esta API não está em conformidade com CLS.

Alternativa em conformidade com CLS

System.Int32.Parse(String)

Converte a representação de cadeia de caracteres de um número em um formato específico de cultura e estilo especificado em seu inteiro sem sinal de 16 bits equivalente.

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

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

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

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

Parâmetros

s

String

Uma cadeia de caracteres que representa o número a ser convertido. A cadeia de caracteres é interpretada usando o estilo especificado pelo parâmetro style.

style

NumberStyles

Uma combinação bit a bit de valores de enumeração que indicam os elementos de estilo que podem estar presentes em s. Um valor típico a ser especificado é Integer.

provider

IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre s.

Retornos

UInt16

Um inteiro sem sinal de 16 bits equivalente ao número especificado em s.

Implementações

Parse(String, NumberStyles, IFormatProvider)

Exceções

ArgumentNullException

s é null.

ArgumentException

style não é um valor NumberStyles.

-ou-

style não é uma combinação de valores AllowHexSpecifier e HexNumber.

FormatException

s não está em um formato compatível com style.

OverflowException

s representa um número menor que UInt16.MinValue ou maior que UInt16.MaxValue.

-ou-

s inclui dígitos fracionários diferentes de zero.

Exemplos

O exemplo a seguir usa o método Parse(String, NumberStyles, IFormatProvider) para converter várias representações de cadeia de caracteres de números em valores inteiros sem sinal de 16 bits.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "fr-FR" };
      NumberStyles[] styles= { NumberStyles.Integer, 
                               NumberStyles.Integer | NumberStyles.AllowDecimalPoint };
      string[] values = { "1702", "+1702.0", "+1702,0", "-1032.00",
                          "-1032,00", "1045.1", "1045,1" };
      
      // Parse strings using each culture
      foreach (string cultureName in cultureNames)
      {
         CultureInfo ci = new CultureInfo(cultureName);
         Console.WriteLine("Parsing strings using the {0} culture", 
                           ci.DisplayName);
         // Use each style.
         foreach (NumberStyles style in styles)
         {
            Console.WriteLine("   Style: {0}", style.ToString());
            // Parse each numeric string.
            foreach (string value in values)
            {
               try {
                  Console.WriteLine("      Converted '{0}' to {1}.", value, 
                                    UInt16.Parse(value, style, ci));
               }                                    
               catch (FormatException) {
                  Console.WriteLine("      Unable to parse '{0}'.", value);   
               }
               catch (OverflowException) {
                  Console.WriteLine("      '{0}' is out of range of the UInt16 type.", 
                                    value);
               }
            }
         }
      }   
   }
}
// The example displays the following output:
//       Parsing strings using the English (United States) culture
//          Style: Integer
//             Converted '1702' to 1702.
//             Unable to parse '+1702.0'.
//             Unable to parse '+1702,0'.
//             Unable to parse '-1032.00'.
//             Unable to parse '-1032,00'.
//             Unable to parse '1045.1'.
//             Unable to parse '1045,1'.
//          Style: Integer, AllowDecimalPoint
//             Converted '1702' to 1702.
//             Converted '+1702.0' to 1702.
//             Unable to parse '+1702,0'.
//             '-1032.00' is out of range of the UInt16 type.
//             Unable to parse '-1032,00'.
//             '1045.1' is out of range of the UInt16 type.
//             Unable to parse '1045,1'.
//       Parsing strings using the French (France) culture
//          Style: Integer
//             Converted '1702' to 1702.
//             Unable to parse '+1702.0'.
//             Unable to parse '+1702,0'.
//             Unable to parse '-1032.00'.
//             Unable to parse '-1032,00'.
//             Unable to parse '1045.1'.
//             Unable to parse '1045,1'.
//          Style: Integer, AllowDecimalPoint
//             Converted '1702' to 1702.
//             Unable to parse '+1702.0'.
//             Converted '+1702,0' to 1702.
//             Unable to parse '-1032.00'.
//             '-1032,00' is out of range of the UInt16 type.
//             Unable to parse '1045.1'.
//             '1045,1' is out of range of the UInt16 type.

open System
open System.Globalization

let cultureNames = [| "en-US"; "fr-FR" |]
let styles = 
    [| NumberStyles.Integer; NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint |]
let values =
    [| "1702"; "+1702.0"; "+1702,0"; "-1032.00"; "-1032,00"; "1045.1"; "1045,1" |]

// Parse strings using each culture
for cultureName in cultureNames do
    let ci = CultureInfo cultureName
    printfn $"Parsing strings using the {ci.DisplayName} culture"
    // Use each style.
    for style in styles do
        printfn $"   Style: {style}"
        // Parse each numeric string.
        for value in values do
            try
                printfn $"      Converted '{value}' to {UInt16.Parse(value, style, ci)}."
            with
            | :? FormatException ->
                printfn $"      Unable to parse '{value}'."
            | :? OverflowException ->
                printfn $"      '{value}' is out of range of the UInt16 type."
// The example displays the following output:
//       Parsing strings using the English (United States) culture
//          Style: Integer
//             Converted '1702' to 1702.
//             Unable to parse '+1702.0'.
//             Unable to parse '+1702,0'.
//             Unable to parse '-1032.00'.
//             Unable to parse '-1032,00'.
//             Unable to parse '1045.1'.
//             Unable to parse '1045,1'.
//          Style: Integer, AllowDecimalPoint
//             Converted '1702' to 1702.
//             Converted '+1702.0' to 1702.
//             Unable to parse '+1702,0'.
//             '-1032.00' is out of range of the UInt16 type.
//             Unable to parse '-1032,00'.
//             '1045.1' is out of range of the UInt16 type.
//             Unable to parse '1045,1'.
//       Parsing strings using the French (France) culture
//          Style: Integer
//             Converted '1702' to 1702.
//             Unable to parse '+1702.0'.
//             Unable to parse '+1702,0'.
//             Unable to parse '-1032.00'.
//             Unable to parse '-1032,00'.
//             Unable to parse '1045.1'.
//             Unable to parse '1045,1'.
//          Style: Integer, AllowDecimalPoint
//             Converted '1702' to 1702.
//             Unable to parse '+1702.0'.
//             Converted '+1702,0' to 1702.
//             Unable to parse '-1032.00'.
//             '-1032,00' is out of range of the UInt16 type.
//             Unable to parse '1045.1'.
//             '1045,1' is out of range of the UInt16 type.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "fr-FR" }
      Dim styles() As NumberStyles = { NumberStyles.Integer, _
                                       NumberStyles.Integer Or NumberStyles.AllowDecimalPoint }
      Dim values() As String = { "1702", "+1702.0", "+1702,0", "-1032.00", _
                                 "-1032,00", "1045.1", "1045,1" }
      
      ' Parse strings using each culture
      For Each cultureName As String In cultureNames
         Dim ci As New CultureInfo(cultureName)
         Console.WriteLine("Parsing strings using the {0} culture", ci.DisplayName)
         ' Use each style.
         For Each style As NumberStyles In styles
            Console.WriteLine("   Style: {0}", style.ToString())
            ' Parse each numeric string.
            For Each value As String In values
               Try
                  Console.WriteLine("      Converted '{0}' to {1}.", value, _
                                    UInt16.Parse(value, style, ci))
               Catch e As FormatException
                  Console.WriteLine("      Unable to parse '{0}'.", value)   
               Catch e As OverflowException
                  Console.WriteLine("      '{0}' is out of range of the UInt16 type.", _
                                    value)         
               End Try
            Next
         Next
      Next                                    
   End Sub
End Module
' The example displays the following output:
'       Parsing strings using the English (United States) culture
'          Style: Integer
'             Converted '1702' to 1702.
'             Unable to parse '+1702.0'.
'             Unable to parse '+1702,0'.
'             Unable to parse '-1032.00'.
'             Unable to parse '-1032,00'.
'             Unable to parse '1045.1'.
'             Unable to parse '1045,1'.
'          Style: Integer, AllowDecimalPoint
'             Converted '1702' to 1702.
'             Converted '+1702.0' to 1702.
'             Unable to parse '+1702,0'.
'             '-1032.00' is out of range of the UInt16 type.
'             Unable to parse '-1032,00'.
'             '1045.1' is out of range of the UInt16 type.
'             Unable to parse '1045,1'.
'       Parsing strings using the French (France) culture
'          Style: Integer
'             Converted '1702' to 1702.
'             Unable to parse '+1702.0'.
'             Unable to parse '+1702,0'.
'             Unable to parse '-1032.00'.
'             Unable to parse '-1032,00'.
'             Unable to parse '1045.1'.
'             Unable to parse '1045,1'.
'          Style: Integer, AllowDecimalPoint
'             Converted '1702' to 1702.
'             Unable to parse '+1702.0'.
'             Converted '+1702,0' to 1702.
'             Unable to parse '-1032.00'.
'             '-1032,00' is out of range of the UInt16 type.
'             Unable to parse '1045.1'.
'             '1045,1' is out of range of the UInt16 type.

Comentários

O parâmetro style define os elementos de estilo (como espaço em branco ou o símbolo de sinal positivo ou negativo) 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]digits[.fractional_digits][E[sign]exponential_digits][ws]

Elementos em colchetes ([ e ]) são opcionais. Se style incluir NumberStyles.AllowHexSpecifier, o parâmetro s poderá incluir os seguintes elementos:

[ws]hexdigits[ws]

A tabela a seguir descreve cada elemento.

Elemento	Descrição
ws	Espaço em branco opcional. O espaço em branco poderá aparecer no início do s se style incluir o sinalizador NumberStyles.AllowLeadingWhite e ele poderá aparecer no final do s se style incluir o sinalizador NumberStyles.AllowTrailingWhite.
$	Um símbolo de moeda específico à cultura. Sua posição na cadeia de caracteres é definida pela propriedade CurrencyPositivePattern do objeto NumberFormatInfo que é retornado pelo método GetFormat do parâmetro provider. O símbolo de moeda poderá aparecer em s se style incluir o sinalizador NumberStyles.AllowCurrencySymbol.
assinar	Um sinal opcional. (O método gerará um OverflowException se s incluir um sinal negativo e representar um número diferente de zero.) O sinal poderá aparecer no início de s se style incluir o sinalizador NumberStyles.AllowLeadingSign e ele poderá aparecer no final do s se style incluir o sinalizador NumberStyles.AllowTrailingSign. Parênteses podem ser usados em s para indicar um valor negativo se style incluir o sinalizador NumberStyles.AllowParentheses.
dígitos	Uma sequência de dígitos de 0 a 9.
.	Um símbolo de ponto decimal específico da cultura. O símbolo de ponto decimal da cultura atual pode aparecer em s se style incluir o sinalizador NumberStyles.AllowDecimalPoint.
fractional_digits	Uma ou mais ocorrências do dígito 0-9 se style incluir o sinalizador NumberStyles.AllowExponent ou uma ou mais ocorrências do dígito 0 se não o fizer. Dígitos fracionários só poderão aparecer em s se style incluir o sinalizador NumberStyles.AllowDecimalPoint.
E	O caractere "e" ou "E", que indica que o valor é representado na notação exponencial (científica). O parâmetro s pode representar um número na notação exponencial se style incluir o sinalizador NumberStyles.AllowExponent.
exponential_digits	Uma sequência de dígitos de 0 a 9. O parâmetro s pode representar um número na notação exponencial se style incluir o sinalizador NumberStyles.AllowExponent.
hexdigits	Uma sequência de dígitos hexadecimal de 0 a f ou 0 a F.

Nota

Todos os caracteres NUL de terminação (U+0000) em s são ignorados pela operação de análise, independentemente do valor do argumento style.

Uma cadeia de caracteres somente com dígitos decimais (que corresponde ao estilo NumberStyles.None) sempre é analisada com êxito. A maioria dos elementos de controle de membros NumberStyles restantes que podem estar presentes, 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.

Valores de NumberStyles não compostos	Elementos permitidos em s além de dígitos
NumberStyles.None	Somente dígitos decimais.
NumberStyles.AllowDecimalPoint	O ponto decimal (.) e fractional_digits elementos. No entanto, se o estilo não incluir o sinalizador NumberStyles.AllowExponent, fractional_digits deverá consistir em apenas um ou mais 0 dígitos; caso contrário, um OverflowException é gerado.
NumberStyles.AllowExponent	O caractere "e" ou "E", que indica notação exponencial, juntamente com exponential_digits.
NumberStyles.AllowLeadingWhite	O elemento ws no início de s.
NumberStyles.AllowTrailingWhite	O elemento ws no final de s.
NumberStyles.AllowLeadingSign	Um sinal antes de dígitos.
NumberStyles.AllowTrailingSign	Um sinal após dígitos.
NumberStyles.AllowParentheses	Parênteses antes e depois dígitos para indicar um valor negativo.
NumberStyles.AllowThousands	O elemento separador de grupo (,).
NumberStyles.AllowCurrencySymbol	O elemento currency ($).

Se o sinalizador NumberStyles.AllowHexSpecifier for usado, s deverá ser um valor hexadecimal. Os dígitos hexadecimal válidos são de 0 a 9, a a f e A a F. Não há suporte para um prefixo, como "0x", e faz com que a operação de análise falhe. Os únicos outros sinalizadores que podem ser combinados com NumberStyles.AllowHexSpecifier 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.)

Nota

Se o parâmetro s for a representação de cadeia de caracteres de um número hexadecimal, ele não poderá ser precedido por qualquer decoração (como 0x ou &h) que a diferencie como um número hexadecimal. Isso faz com que a operação de análise gere uma exceção.

O parâmetro provider é uma implementação IFormatProvider cujo método GetFormat retorna um objeto NumberFormatInfo que fornece informações específicas da cultura sobre o formato de s. Há três maneiras de usar o parâmetro provider para fornecer informações de formatação personalizadas para a operação de análise:

• Você pode passar o objeto NumberFormatInfo real que fornece informações de formatação. (Sua implementação de GetFormat simplesmente retorna a si mesma.)

• Você pode passar um objeto CultureInfo que especifica a cultura cuja formatação deve ser usada. Sua propriedade NumberFormat fornece informações de formatação.

• Você pode passar uma implementação de IFormatProvider personalizada. Seu método GetFormat deve criar uma instância e retornar o objeto NumberFormatInfo que fornece informações de formatação.

Se provider for null, o objeto NumberFormatInfo da cultura atual será usado.

Confira também

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

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Origem:

UInt16.cs

Importante

Esta API não está em conformidade com CLS.

Converte a representação de intervalo de um número em um formato específico de cultura e estilo especificado em seu inteiro sem sinal de 16 bits equivalente.

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

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

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

Parâmetros

s

ReadOnlySpan<Char>

Um intervalo que contém os caracteres que representam o número a ser convertido. O intervalo é interpretado usando o estilo especificado pelo parâmetro style.

style

NumberStyles

Uma combinação bit a bit de valores de enumeração que indicam os elementos de estilo que podem estar presentes em s. Um valor típico a ser especificado é Integer.

provider

IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre s.

Retornos

UInt16

Um inteiro sem sinal de 16 bits equivalente ao número especificado em s.

Implementações

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Origem:

UInt16.cs

Analisa um intervalo de caracteres UTF-8 em um valor.

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

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

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

Parâmetros

utf8Text

ReadOnlySpan<Byte>

O intervalo de caracteres UTF-8 a serem analisados.

style

NumberStyles

Uma combinação bit a bit de estilos numéricos que podem estar presentes em utf8Text.

provider

IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre utf8Text.

Retornos

UInt16

O resultado da análise de utf8Text.

Implementações

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parse(String, IFormatProvider)

Origem:

UInt16.cs

Importante

Esta API não está em conformidade com CLS.

Alternativa em conformidade com CLS

System.Int32.Parse(String)

Converte a representação de cadeia de caracteres de um número em um formato específico à cultura especificado em seu inteiro sem sinal de 16 bits equivalente.

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

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

static member Parse : string * IFormatProvider -> uint16

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

Parâmetros

s

String

Uma cadeia de caracteres que representa o número a ser convertido.

provider

IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre s.

Retornos

UInt16

Um inteiro sem sinal de 16 bits equivalente ao número especificado em s.

Implementações

Parse(String, IFormatProvider)

Exceções

ArgumentNullException

s é null.

FormatException

s não está no formato correto.

OverflowException

s representa um número menor que UInt16.MinValue ou maior que UInt16.MaxValue.

Exemplos

O exemplo a seguir cria uma instância de uma cultura personalizada que usa dois sinais de adição (++) como sinal positivo. Em seguida, ele chama o método Parse(String, IFormatProvider) para analisar uma matriz de cadeias de caracteres usando CultureInfo objetos que representam essa cultura personalizada e a cultura invariável.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Define a custom culture that uses "++" as a positive sign. 
      CultureInfo ci = new CultureInfo("");
      ci.NumberFormat.PositiveSign = "++";
      // Create an array of cultures.
      CultureInfo[] cultures = { ci, CultureInfo.InvariantCulture };
      // Create an array of strings to parse.
      string[] values = { "++1403", "-0", "+0", "+16034", 
                          Int16.MinValue.ToString(), "14.0", "18012" };
      // Parse the strings using each culture.
      foreach (CultureInfo culture in cultures)
      {
         Console.WriteLine("Parsing with the '{0}' culture.", culture.Name);
         foreach (string value in values)
         {
            try {
               ushort number = UInt16.Parse(value, culture);
               Console.WriteLine("   Converted '{0}' to {1}.", value, number);
            }
            catch (FormatException) {
               Console.WriteLine("   The format of '{0}' is invalid.", value);
            }
            catch (OverflowException) {
               Console.WriteLine("   '{0}' is outside the range of a UInt16 value.", value);
            }               
         }
      }
   }
}
// The example displays the following output:
//       Parsing with the  culture.
//          Converted '++1403' to 1403.
//          Converted '-0' to 0.
//          The format of '+0' is invalid.
//          The format of '+16034' is invalid.
//          '-32768' is outside the range of a UInt16 value.
//          The format of '14.0' is invalid.
//          Converted '18012' to 18012.
//       Parsing with the '' culture.
//          The format of '++1403' is invalid.
//          Converted '-0' to 0.
//          Converted '+0' to 0.
//          Converted '+16034' to 16034.
//          '-32768' is outside the range of a UInt16 value.
//          The format of '14.0' is invalid.
//          Converted '18012' to 18012.

open System
open System.Globalization

// Define a custom culture that uses "++" as a positive sign. 
let ci = CultureInfo ""
ci.NumberFormat.PositiveSign <- "++"
// Create an array of cultures.
let cultures = [| ci; CultureInfo.InvariantCulture |]
// Create an array of strings to parse.
let values = 
    [| "++1403"; "-0"; "+0"; "+16034" 
       string Int16.MinValue; "14.0"; "18012" |]
// Parse the strings using each culture.
for culture in cultures do
    printfn $"Parsing with the '{culture.Name}' culture."
    for value in values do
        try
            let number = UInt16.Parse(value, culture)
            printfn $"   Converted '{value}' to {number}."
        with
        | :? FormatException ->
            printfn $"   The format of '{value}' is invalid."
        | :? OverflowException ->
            printfn $"   '{value}' is outside the range of a UInt16 value."
// The example displays the following output:
//       Parsing with the  culture.
//          Converted '++1403' to 1403.
//          Converted '-0' to 0.
//          The format of '+0' is invalid.
//          The format of '+16034' is invalid.
//          '-32768' is outside the range of a UInt16 value.
//          The format of '14.0' is invalid.
//          Converted '18012' to 18012.
//       Parsing with the '' culture.
//          The format of '++1403' is invalid.
//          Converted '-0' to 0.
//          Converted '+0' to 0.
//          Converted '+16034' to 16034.
//          '-32768' is outside the range of a UInt16 value.
//          The format of '14.0' is invalid.
//          Converted '18012' to 18012.

Imports System.Globalization

Module Example
   Public Sub Main()
      ' Define a custom culture that uses "++" as a positive sign. 
      Dim ci As CultureInfo = New CultureInfo("")
      ci.NumberFormat.PositiveSign = "++"
      ' Create an array of cultures.
      Dim cultures() As CultureInfo = { ci, CultureInfo.InvariantCulture }
      ' Create an array of strings to parse.
      Dim values() As String = { "++1403", "-0", "+0", "+16034", _
                                 Int16.MinValue.ToString(), "14.0", "18012" }
      ' Parse the strings using each culture.
      For Each culture As CultureInfo In cultures
         Console.WriteLine("Parsing with the '{0}' culture.", culture.Name)
         For Each value As String In values
            Try
               Dim number As UShort = UInt16.Parse(value, culture)
               Console.WriteLine("   Converted '{0}' to {1}.", value, number)
            Catch e As FormatException
               Console.WriteLine("   The format of '{0}' is invalid.", value)
            Catch e As OverflowException
               Console.WriteLine("   '{0}' is outside the range of a UInt16 value.", value)
            End Try               
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       Parsing with the  culture.
'          Converted '++1403' to 1403.
'          Converted '-0' to 0.
'          The format of '+0' is invalid.
'          The format of '+16034' is invalid.
'          '-32768' is outside the range of a UInt16 value.
'          The format of '14.0' is invalid.
'          Converted '18012' to 18012.
'       Parsing with the '' culture.
'          The format of '++1403' is invalid.
'          Converted '-0' to 0.
'          Converted '+0' to 0.
'          Converted '+16034' to 16034.
'          '-32768' is outside the range of a UInt16 value.
'          The format of '14.0' is invalid.
'          Converted '18012' to 18012.

Comentários

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

[ws] [assinar]dígitos[ws]

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

Elemento	Descrição
Ws	Espaço em branco opcional.
sinal	Um sinal opcional ou um sinal negativo se s representar o valor zero.
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 do valor de byte, somente espaços à esquerda e à direita, juntamente com um sinal à esquerda, são permitidos. (Se o sinal negativo estiver presente, s deverá representar um valor igual a zero ou o método gerará um OverflowException.) Para definir explicitamente os elementos de estilo junto com as informações de formatação específicas da cultura que podem estar presentes em s, use o método Parse(String, NumberStyles, IFormatProvider).

O parâmetro provider é uma implementação IFormatProvider cujo método GetFormat retorna um objeto NumberFormatInfo que fornece informações específicas da cultura sobre o formato de s. Há três maneiras de usar o parâmetro provider para fornecer informações de formatação personalizadas para a operação de análise:

• Você pode passar o objeto NumberFormatInfo real que fornece informações de formatação. (Sua implementação de GetFormat simplesmente retorna a si mesma.)

• Você pode passar um objeto CultureInfo que especifica a cultura cuja formatação deve ser usada. Sua propriedade NumberFormat fornece informações de formatação.

• Você pode passar uma implementação de IFormatProvider personalizada. Seu método GetFormat deve criar uma instância e retornar o objeto NumberFormatInfo que fornece informações de formatação.

Se provider for null, o NumberFormatInfo da cultura atual será usado.

Confira também

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

Parse(String, NumberStyles)

Origem:

UInt16.cs

Importante

Esta API não está em conformidade com CLS.

Converte a representação de cadeia de caracteres de um número em um estilo especificado em seu inteiro sem sinal de 16 bits equivalente.

Esse método não é compatível com CLS. A alternativa compatível com CLS é Parse(String, NumberStyles).

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

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

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

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

Parâmetros

s

String

Uma cadeia de caracteres que representa o número a ser convertido. A cadeia de caracteres é interpretada usando o estilo especificado pelo parâmetro style.

style

NumberStyles

Uma combinação bit a bit dos valores de enumeração que especificam o formato permitido de s. Um valor típico a ser especificado é Integer.

Retornos

UInt16

Um inteiro sem sinal de 16 bits equivalente ao número especificado em s.

Exceções

ArgumentNullException

s é null.

ArgumentException

style não é um valor NumberStyles.

-ou-

style não é uma combinação de valores AllowHexSpecifier e HexNumber.

FormatException

s não está em um formato compatível com style.

OverflowException

s representa um número menor que UInt16.MinValue ou maior que UInt16.MaxValue.

-ou-

s inclui dígitos fracionários diferentes de zero.

Exemplos

O exemplo a seguir tenta analisar cada elemento em uma matriz de cadeia de caracteres usando uma série de valores NumberStyles.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] values = { " 214 ", "1,064", "(0)", "1241+", " + 214 ", " +214 ", "2153.0", "1e03", "1300.0e-2" };
      NumberStyles whitespace =  NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite;
      NumberStyles[] styles = { NumberStyles.None, whitespace, 
                                NumberStyles.AllowLeadingSign | NumberStyles.AllowTrailingSign | whitespace, 
                                NumberStyles.AllowThousands | NumberStyles.AllowCurrencySymbol, 
                                NumberStyles.AllowExponent | NumberStyles.AllowDecimalPoint };

      // Attempt to convert each number using each style combination.
      foreach (string value in values)
      {
         Console.WriteLine("Attempting to convert '{0}':", value);
         foreach (NumberStyles style in styles)
         {
            try {
               ushort number = UInt16.Parse(value, style);
               Console.WriteLine("   {0}: {1}", style, number);
            }   
            catch (FormatException) {
               Console.WriteLine("   {0}: Bad Format", style);
            }
         }
         Console.WriteLine();
      }
   }
}
// The example display the following output:
//    Attempting to convert ' 214 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: 214
//       Integer, AllowTrailingSign: 214
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '1,064':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: 1064
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '(0)':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '1241+':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: 1241
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert ' + 214 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert ' +214 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: 214
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '2153.0':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 2153
//    
//    Attempting to convert '1e03':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 1000
//    
//    Attempting to convert '1300.0e-2':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 13

open System
open System.Globalization

let values = [| " 214 "; "1,064"; "(0)"; "1241+"; " + 214 "; " +214 "; "2153.0"; "1e03"; "1300.0e-2" |]
let whitespace =  NumberStyles.AllowLeadingWhite ||| NumberStyles.AllowTrailingWhite
let styles = 
    [| NumberStyles.None; whitespace 
       NumberStyles.AllowLeadingSign ||| NumberStyles.AllowTrailingSign ||| whitespace 
       NumberStyles.AllowThousands ||| NumberStyles.AllowCurrencySymbol
       NumberStyles.AllowExponent ||| NumberStyles.AllowDecimalPoint |]

// Attempt to convert each number using each style combination.
for value in values do
    printfn $"Attempting to convert '{value}':"
    for style in styles do
        try
            let number = UInt16.Parse(value, style)
            printfn $"   {style}: {number}"
        with :? FormatException ->
            printfn $"   {style}: Bad Format"
    printfn ""
// The example display the following output:
//    Attempting to convert ' 214 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: 214
//       Integer, AllowTrailingSign: 214
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '1,064':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: 1064
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '(0)':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '1241+':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: 1241
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert ' + 214 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert ' +214 ':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: 214
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: Bad Format
//    
//    Attempting to convert '2153.0':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 2153
//    
//    Attempting to convert '1e03':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 1000
//    
//    Attempting to convert '1300.0e-2':
//       None: Bad Format
//       AllowLeadingWhite, AllowTrailingWhite: Bad Format
//       Integer, AllowTrailingSign: Bad Format
//       AllowThousands, AllowCurrencySymbol: Bad Format
//       AllowDecimalPoint, AllowExponent: 13

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim values() As String = { " 214 ", "1,064", "(0)", "1241+", " + 214 ", " +214 ", "2153.0", "1e03", "1300.0e-2" }
      Dim whitespace As NumberStyles =  NumberStyles.AllowLeadingWhite Or NumberStyles.AllowTrailingWhite
      Dim styles() As NumberStyles = { NumberStyles.None, _
                                       whitespace, _
                                       NumberStyles.AllowLeadingSign Or NumberStyles.AllowTrailingSign Or whitespace, _
                                       NumberStyles.AllowThousands Or NumberStyles.AllowCurrencySymbol, _
                                       NumberStyles.AllowExponent Or NumberStyles.AllowDecimalPoint }

      ' Attempt to convert each number using each style combination.
      For Each value As String In values
         Console.WriteLine("Attempting to convert '{0}':", value)
         For Each style As NumberStyles In styles
            Try
               Dim number As UShort = UInt16.Parse(value, style)
               Console.WriteLine("   {0}: {1}", style, number)
            Catch e As FormatException
               Console.WriteLine("   {0}: Bad Format", style)
            End Try         
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'    Attempting to convert ' 214 ':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: 214
'       Integer, AllowTrailingSign: 214
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert '1,064':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: 1064
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert '(0)':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert '1241+':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: 1241
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert ' + 214 ':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert ' +214 ':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: 214
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: Bad Format
'    
'    Attempting to convert '2153.0':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: 2153
'    
'    Attempting to convert '1e03':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: 1000
'    
'    Attempting to convert '1300.0e-2':
'       None: Bad Format
'       AllowLeadingWhite, AllowTrailingWhite: Bad Format
'       Integer, AllowTrailingSign: Bad Format
'       AllowThousands, AllowCurrencySymbol: Bad Format
'       AllowDecimalPoint, AllowExponent: 13

Comentários

O parâmetro style define os elementos de estilo (como espaço em branco, o símbolo de sinal positivo ou negativo, o símbolo do separador de grupo ou o símbolo de ponto decimal) que são permitidos no parâmetro s para que a operação de análise tenha êxito. style deve ser uma combinação de sinalizadores de bits da enumeração NumberStyles. O parâmetro style torna essa sobrecarga de método útil quando s contém a representação de cadeia de caracteres de um valor hexadecimal, quando o sistema de números (decimal ou hexadecimal) representado por s é conhecido apenas em tempo de execução ou quando você deseja não permitir espaço em branco ou um símbolo de sinal no s.

Dependendo do valor de style, o parâmetro s pode incluir os seguintes elementos:

[ws] [] [assinar] [dígitos,]dígitos[.fractional_digits][E[de sinal de]exponential_digits][ws]

Elementos em colchetes ([ e ]) são opcionais. Se style incluir NumberStyles.AllowHexSpecifier, o parâmetro s poderá conter os seguintes elementos:

[ws]hexdigits[ws]

A tabela a seguir descreve cada elemento.

Elemento	Descrição
ws	Espaço em branco opcional. O espaço em branco poderá aparecer no início do s se style incluir o sinalizador NumberStyles.AllowLeadingWhite e ele poderá aparecer no final do s se style incluir o sinalizador NumberStyles.AllowTrailingWhite.
$	Um símbolo de moeda específico à cultura. Sua posição na cadeia de caracteres é definida pelas propriedades NumberFormatInfo.CurrencyNegativePattern e NumberFormatInfo.CurrencyPositivePattern da cultura atual. O símbolo de moeda da cultura atual pode aparecer em s se style incluir o sinalizador NumberStyles.AllowCurrencySymbol.
assinar	Um sinal opcional. O sinal poderá aparecer no início do s se style incluir o sinalizador NumberStyles.AllowLeadingSign e ele poderá aparecer no final do s se style incluir o sinalizador de NumberStyles.AllowTrailingSign. Parênteses podem ser usados em s para indicar um valor negativo se style incluir o sinalizador NumberStyles.AllowParentheses. No entanto, o símbolo de sinal negativo só pode ser usado com zero; caso contrário, o método lança um OverflowException.
dígitos fractional_digits exponential_digits	Uma sequência de dígitos de 0 a 9. Para fractional_digits, somente o dígito 0 é válido.
,	Um símbolo de separador de grupo específico à cultura. O separador de grupo da cultura atual pode aparecer em s se style incluir o sinalizador NumberStyles.AllowThousands.
.	Um símbolo de ponto decimal específico da cultura. O símbolo de ponto decimal da cultura atual pode aparecer em s se style incluir o sinalizador NumberStyles.AllowDecimalPoint. Somente o dígito 0 pode aparecer como um dígito fracionário para que a operação de análise tenha êxito; se fractional_digits incluir qualquer outro dígito, um FormatException será gerado.
E	O caractere "e" ou "E", que indica que o valor é representado na notação exponencial (científica). O parâmetro s pode representar um número na notação exponencial se style incluir o sinalizador NumberStyles.AllowExponent.
hexdigits	Uma sequência de dígitos hexadecimal de 0 a f ou 0 a F.

Nota

Todos os caracteres NUL de terminação (U+0000) em s são ignorados pela operação de análise, independentemente do valor do argumento style.

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 UInt16. A maioria dos elementos de controle de membros NumberStyles restantes que podem estar presentes, 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.

NumberStyles valor	Elementos permitidos em s além de dígitos
None	O dígitos elemento somente.
AllowDecimalPoint	O ponto decimal (.) e dígitos fracionários elementos.
AllowExponent	O caractere "e" ou "E", que indica notação exponencial, juntamente com exponential_digits.
AllowLeadingWhite	O elemento ws no início de s.
AllowTrailingWhite	O elemento ws no final de s.
AllowLeadingSign	O elemento de sinal no início de .
AllowTrailingSign	O elemento de sinal no final do .
AllowParentheses	O sinal elemento na forma de parênteses que incluem o valor numérico.
AllowThousands	O elemento separador de grupo (,).
AllowCurrencySymbol	O elemento currency ($).
Currency	Todos os elementos. No entanto, s não pode representar um número hexadecimal ou um número na notação exponencial.
Float	O elemento ws no início ou no final de s, de sinal no início do se no símbolo decimal point (.). O parâmetro s também pode usar notação exponencial.
Number	Os elementos ws, sign, separador de grupo (,) e ponto decimal (.).
Any	Todos os elementos. No entanto, s não pode representar um número hexadecimal.

Ao contrário dos outros valores NumberStyles, que permitem, mas não exigem, a presença de elementos de estilo específicos em s, o valor de estilo NumberStyles.AllowHexSpecifier significa que os caracteres numéricos individuais em s são sempre interpretados como caracteres hexadecimal. Os caracteres hexadecimal válidos são 0-9, A-F e a-f. Não há suporte para um prefixo, como "0x", e faz com que a operação de análise falhe. Os únicos outros sinalizadores que podem ser combinados com o parâmetro style 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.)

Nota

Se s for a representação de cadeia de caracteres de um número hexadecimal, ela não poderá ser precedida por qualquer decoração (como 0x ou &h) que a diferencie como um número hexadecimal. Isso faz com que a conversão falhe.

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 Parse(String, NumberStyles, IFormatProvider).

Confira também

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

Parse(ReadOnlySpan<Char>, IFormatProvider)

Origem:

UInt16.cs

Analisa um intervalo de caracteres em um valor.

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

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

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

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

Parâmetros

s

ReadOnlySpan<Char>

O intervalo de caracteres a serem analisados.

provider

IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre s.

Retornos

UInt16

O resultado da análise de s.

Implementações

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Origem:

UInt16.cs

Analisa um intervalo de caracteres UTF-8 em um valor.

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

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

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

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

Parâmetros

utf8Text

ReadOnlySpan<Byte>

O intervalo de caracteres UTF-8 a serem analisados.

provider

IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre utf8Text.

Retornos

UInt16

O resultado da análise de utf8Text.

Implementações

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parse(String)

Origem:

UInt16.cs

Importante

Esta API não está em conformidade com CLS.

Alternativa em conformidade com CLS

System.Int32.Parse(String)

Converte a representação de cadeia de caracteres de um número em seu equivalente inteiro sem sinal de 16 bits.

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

public static ushort Parse (string s);

static member Parse : string -> uint16

Public Shared Function Parse (s As String) As UShort

Parâmetros

s

String

Uma cadeia de caracteres que representa o número a ser convertido.

Retornos

UInt16

Um inteiro sem sinal de 16 bits equivalente ao número contido em s.

Exceções

ArgumentNullException

s é null.

FormatException

s não está no formato correto.

OverflowException

s representa um número menor que UInt16.MinValue ou maior que UInt16.MaxValue.

Exemplos

O exemplo a seguir chama o método Parse(String) para converter cada elemento em uma matriz de cadeia de caracteres em um inteiro de 16 bits sem sinal.

using System;

public class Example
{
   public static void Main()
   {
      string[] values = { "-0", "17", "-12", "185", "66012", "+0", 
                          "", null, "16.1", "28.0", "1,034" };
      foreach (string value in values)
      {
         try {
            ushort number = UInt16.Parse(value);
            Console.WriteLine("'{0}' --> {1}", value, number);
         }
         catch (FormatException) {
            Console.WriteLine("'{0}' --> Bad Format", value);
         }
         catch (OverflowException) {   
            Console.WriteLine("'{0}' --> OverflowException", value);
         }
         catch (ArgumentNullException) {
            Console.WriteLine("'{0}' --> Null", value);
         }
      }                                 
   }
}
// The example displays the following output:
//       '-0' --> 0
//       '17' --> 17
//       '-12' --> OverflowException
//       '185' --> 185
//       '66012' --> OverflowException
//       '+0' --> 0
//       '' --> Bad Format
//       '' --> Null
//       '16.1' --> Bad Format
//       '28.0' --> Bad Format
//       '1,034' --> Bad Format

open System

let values = 
    [| "-0"; "17"; "-12"; "185"; "66012"; "+0" 
       ""; null; "16.1"; "28.0"; "1,034" |]
for value in values do
    try
        let number = UInt16.Parse value
        printfn $"'{value}' --> {number}"
    with
    | :? FormatException ->
        printfn $"'{value}' --> Bad Format"
    | :? OverflowException ->
        printfn $"'{value}' --> OverflowException"
    | :? ArgumentNullException ->
        printfn $"'{value}' --> Null"
// The example displays the following output:
//       '-0' --> 0
//       '17' --> 17
//       '-12' --> OverflowException
//       '185' --> 185
//       '66012' --> OverflowException
//       '+0' --> 0
//       '' --> Bad Format
//       '' --> Null
//       '16.1' --> Bad Format
//       '28.0' --> Bad Format
//       '1,034' --> Bad Format

Module Example
   Public Sub Main()
      Dim values() As String = { "-0", "17", "-12", "185", "66012", _ 
                                 "+0", "", Nothing, "16.1", "28.0", _
                                 "1,034" }
      For Each value As String In values
         Try
            Dim number As UShort = UInt16.Parse(value)
            Console.WriteLine("'{0}' --> {1}", value, number)
         Catch e As FormatException
            Console.WriteLine("'{0}' --> Bad Format", value)
         Catch e As OverflowException   
            Console.WriteLine("'{0}' --> OverflowException", value)
         Catch e As ArgumentNullException
            Console.WriteLine("'{0}' --> Null", value)
         End Try
      Next                                 
   End Sub
End Module
' The example displays the following output:
'       '-0' --> 0
'       '17' --> 17
'       '-12' --> OverflowException
'       '185' --> 185
'       '66012' --> OverflowException
'       '+0' --> 0
'       '' --> Bad Format
'       '' --> Null
'       '16.1' --> Bad Format
'       '28.0' --> Bad Format
'       '1,034' --> Bad Format

Comentários

O parâmetro s deve ser a representação de cadeia de caracteres de um número no formulário a seguir.

[ws] [assinar]dígitos[ws]

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

Elemento	Descrição
ws	Espaço em branco opcional.
assinar	Um sinal opcional. Caracteres de sinal válidos são determinados pelas propriedades NumberFormatInfo.NegativeSign e NumberFormatInfo.PositiveSign da cultura atual. No entanto, o símbolo de sinal negativo só pode ser usado com zero; caso contrário, o método lança um OverflowException.
dígitos	Uma sequência de dígitos variando de 0 a 9. Todos os zeros à esquerda são ignorados.

Nota

A cadeia de caracteres especificada pelo parâmetro s é interpretada usando o estilo NumberStyles.Integer. Ele não pode conter separadores de grupo ou separador decimal e não pode ter uma parte decimal.

O parâmetro s é analisado usando as informações de formatação em um objeto System.Globalization.NumberFormatInfo inicializado para a cultura atual do sistema. Para obter mais informações, consulte NumberFormatInfo.CurrentInfo. Para analisar uma cadeia de caracteres usando as informações de formatação de uma cultura específica, use o método Parse(String, IFormatProvider).

Confira também

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