Byte.TryParse Método

Definição

Espaço de Nomes:: System

Assemblagens:: netstandard.dll, System.Runtime.dll

Assemblagem:: System.Runtime.dll

Assemblagem:: netstandard.dll

Assemblagens:: mscorlib.dll, System.Runtime.dll

Assemblagem:: mscorlib.dll

Importante

Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.

Tenta converter a representação da cadeia de um número para o seu Byte equivalente e devolve um valor que indica se a conversão foi bem-sucedida.

Sobrecargas

Name	Description
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)	Tenta separar um intervalo de caracteres UTF-8 num valor.
TryParse(ReadOnlySpan<Char>, Byte)	Tenta converter a representação span de um número para o seu Byte equivalente e retorna um valor que indica se a conversão teve sucesso.
TryParse(String, Byte)	Tenta converter a representação da cadeia de um número para o seu Byte equivalente e devolve um valor que indica se a conversão foi bem-sucedida.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)	Tenta separar um intervalo de caracteres num valor.
TryParse(String, IFormatProvider, Byte)	Tenta analisar uma cadeia num valor.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Byte)	Tenta separar um intervalo de caracteres UTF-8 num valor.
TryParse(ReadOnlySpan<Byte>, Byte)	Tenta converter um intervalo de caracteres UTF-8 contendo a representação da cadeia de um número para o seu equivalente inteiro sem sinal de 8 bits.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Byte)	Converte a representação span de um número num estilo especificado e formato específico de cultura para o seu Byte equivalente. Um valor de retorno indica se a conversão teve sucesso ou falhou.
TryParse(String, NumberStyles, IFormatProvider, Byte)	Converte a representação em cadeia de um número num estilo especificado e formato específico de cultura para o seu Byte equivalente. Um valor de retorno indica se a conversão teve sucesso ou falhou.

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Tenta separar um intervalo de caracteres UTF-8 num valor.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result) = IUtf8SpanParsable<System::Byte>::TryParse;

public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, out byte result);

static member TryParse : ReadOnlySpan<byte> * IFormatProvider * byte -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider, ByRef result As Byte) As Boolean

Parâmetros

utf8Text: ReadOnlySpan<Byte>

A extensão de caracteres UTF-8 para analisar.

provider: IFormatProvider

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

result: Byte

No retorno, contém o resultado de uma análise utf8Text bem-sucedida ou um valor indefinido em caso de falha.

Devoluções

Boolean

true se utf8Text foi analisado com sucesso; caso contrário, false.

Aplica-se a

TryParse(ReadOnlySpan<Char>, Byte)

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Tenta converter a representação span de um número para o seu Byte equivalente e retorna um valor que indica se a conversão teve sucesso.

public:
 static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] System::Byte % result);

public static bool TryParse(ReadOnlySpan<char> s, out byte result);

static member TryParse : ReadOnlySpan<char> * byte -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As Byte) As Boolean

Parâmetros

s: ReadOnlySpan<Char>

Um espaço que contém os caracteres que representam o número a converter.

result: Byte

Quando este método retorna, contém o Byte valor equivalente ao número contido em s se a conversão foi bem-sucedida, ou zero se a conversão falhou. Este parâmetro é passado sem inicializar; qualquer valor originalmente fornecido result será sobrescrito.

Devoluções

Boolean

true se s foi convertido com sucesso; caso contrário, false.

Aplica-se a

TryParse(String, Byte)

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Tenta converter a representação da cadeia de um número para o seu Byte equivalente e devolve um valor que indica se a conversão foi bem-sucedida.

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] System::Byte % result);

public static bool TryParse(string s, out byte result);

public static bool TryParse(string? s, out byte result);

static member TryParse : string * byte -> bool

Public Shared Function TryParse (s As String, ByRef result As Byte) As Boolean

Parâmetros

s: String

Uma cadeia que contém um número a converter.

result: Byte

Devoluções

Boolean

true se s foi convertido com sucesso; caso contrário, false.

Exemplos

O exemplo seguinte chama o TryParse(String, Byte) método com vários valores de cadeia diferentes.

using System;

public class ByteConversion
{
   public static void Main()
   {
      string[] byteStrings = { null, string.Empty, "1024",
                               "100.1", "100", "+100", "-100",
                               "000000000000000100", "00,100",
                               "   20   ", "FF", "0x1F" };

      foreach (var byteString in byteStrings)
      {
          CallTryParse(byteString);
      }
   }

   private static void CallTryParse(string stringToConvert)
   {
      byte byteValue;
      bool success = Byte.TryParse(stringToConvert, out byteValue);
      if (success)
      {
         Console.WriteLine("Converted '{0}' to {1}",
                        stringToConvert, byteValue);
      }
      else
      {
         Console.WriteLine("Attempted conversion of '{0}' failed.",
                           stringToConvert);
      }
   }
}
// The example displays the following output to the console:
//       Attempted conversion of '' failed.
//       Attempted conversion of '' failed.
//       Attempted conversion of '1024' failed.
//       Attempted conversion of '100.1' failed.
//       Converted '100' to 100
//       Converted '+100' to 100
//       Attempted conversion of '-100' failed.
//       Converted '000000000000000100' to 100
//       Attempted conversion of '00,100' failed.
//       Converted '   20   ' to 20
//       Attempted conversion of 'FF' failed.
//       Attempted conversion of '0x1F' failed.

open System

let callTryParse (stringToConvert: string) =
    match Byte.TryParse stringToConvert with
    | true, byteValue ->
        printfn $"Converted '{stringToConvert}' to {byteValue}"
    | _ ->
        printfn $"Attempted conversion of '{stringToConvert}' failed."

let byteStrings = 
    [ null; String.Empty; "1024"
      "100.1"; "100"; "+100"; "-100"
      "000000000000000100"; "00,100"
      "   20   "; "FF"; "0x1F" ]

for byteString in byteStrings do
    callTryParse byteString

// The example displays the following output to the console:
//       Attempted conversion of '' failed.
//       Attempted conversion of '' failed.
//       Attempted conversion of '1024' failed.
//       Attempted conversion of '100.1' failed.
//       Converted '100' to 100
//       Converted '+100' to 100
//       Attempted conversion of '-100' failed.
//       Converted '000000000000000100' to 100
//       Attempted conversion of '00,100' failed.
//       Converted '   20   ' to 20
//       Attempted conversion of 'FF' failed.
//       Attempted conversion of '0x1F' failed.

Module ByteConversion
   Public Sub Main()
      Dim byteStrings() As String = { Nothing, String.Empty, "1024", 
                                    "100.1", "100", "+100", "-100",
                                    "000000000000000100", "00,100",
                                    "   20   ", "FF", "0x1F"}

      For Each byteString As String In byteStrings
        CallTryParse(byteString)
      Next
   End Sub
   
   Private Sub CallTryParse(stringToConvert As String)  
      Dim byteValue As Byte
      Dim success As Boolean = Byte.TryParse(stringToConvert, byteValue)
      If success Then
         Console.WriteLine("Converted '{0}' to {1}", _
                        stringToConvert, byteValue)
      Else
         Console.WriteLine("Attempted conversion of '{0}' failed.", _
                           stringToConvert)
      End If                        
   End Sub
End Module
' The example displays the following output to the console:
'       Attempted conversion of '' failed.
'       Attempted conversion of '' failed.
'       Attempted conversion of '1024' failed.
'       Attempted conversion of '100.1' failed.
'       Converted '100' to 100
'       Converted '+100' to 100
'       Attempted conversion of '-100' failed.
'       Converted '000000000000000100' to 100
'       Attempted conversion of '00,100' failed.
'       Converted '   20   ' to 20
'       Attempted conversion of 'FF' failed.
'       Attempted conversion of '0x1F' failed.

Observações

A conversão falha e o método retorna false se o s parâmetro não estiver no formato correto, se for null ou String.Empty, ou se representar um número menor ou maior que MinValue MaxValue .

O Byte.TryParse(String, Byte) método é semelhante ao Byte.Parse(String) método, exceto que TryParse(String, Byte) não lança uma exceção se a conversão falhar.

O s parâmetro deve ser a representação em cadeia de um número na seguinte forma:

[ws][sign]digits[ws]

Os elementos entre parênteses retos ([ e ]) são opcionais. A tabela a seguir descreve cada elemento.

Elemento	Descrição
ws	Espaço em branco opcional.
assinar	Um signo positivo opcional, conforme especificado pela NumberFormatInfo.PositiveSign propriedade da cultura atual.
dígitos	Uma sequência de dígitos decimais que variam de 0 a 9.

O s parâmetro é interpretado usando o Integer estilo. Para além dos dígitos decimais do valor do byte, apenas os espaços iniciais e finais juntamente com um sinal inicial são permitidos. (Se o sinal estiver presente, deve ser um sinal positivo ou o método lança um OverflowException.) Para definir explicitamente os elementos de estilo juntamente com a informação de formatação específica da cultura que pode estar presente em s, utilize o Byte.Parse(String, NumberStyles, IFormatProvider) método.

O s parâmetro é analisado usando a informação de formatação de um NumberFormatInfo objeto para a cultura atual. Para obter mais informações, veja NumberFormatInfo.CurrentInfo.

Esta sobrecarga do Byte.TryParse(String, Byte) método interpreta todos os dígitos do s parâmetro como dígitos decimais. Para analisar a representação da cadeia de um número hexadecimal, chama-se a Byte.TryParse(String, NumberStyles, IFormatProvider, Byte) sobrecarga.

Ver também

Aplica-se a

TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Tenta separar um intervalo de caracteres num valor.

public:
 static bool TryParse(ReadOnlySpan<char> s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result) = ISpanParsable<System::Byte>::TryParse;

public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out byte result);

static member TryParse : ReadOnlySpan<char> * IFormatProvider * byte -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As Byte) As Boolean

Parâmetros

s: ReadOnlySpan<Char>

O número de personagens a analisar.

provider: IFormatProvider

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

result: Byte

Quando este método retorna, contém o resultado de uma sanálise bem-sucedida , ou um valor indefinido em caso de falha.

Devoluções

Boolean

true se s foi analisado com sucesso; caso contrário, false.

Aplica-se a

TryParse(String, IFormatProvider, Byte)

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Tenta analisar uma cadeia num valor.

public:
 static bool TryParse(System::String ^ s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result) = IParsable<System::Byte>::TryParse;

public static bool TryParse(string? s, IFormatProvider? provider, out byte result);

static member TryParse : string * IFormatProvider * byte -> bool

Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As Byte) As Boolean

Parâmetros

s: String

A sequência a analisar.

provider: IFormatProvider

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

result: Byte

Quando este método retorna, contém o resultado de uma s análise bem-sucedida ou um valor indefinido em caso de falha.

Devoluções

Boolean

true se s foi analisado com sucesso; caso contrário, false.

Aplica-se a

TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Byte)

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Tenta separar um intervalo de caracteres UTF-8 num valor.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result) = System::Numerics::INumberBase<System::Byte>::TryParse;

public static bool TryParse(ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style, IFormatProvider? provider, out byte result);

static member TryParse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider * byte -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), style As NumberStyles, provider As IFormatProvider, ByRef result As Byte) As Boolean

Parâmetros

utf8Text: ReadOnlySpan<Byte>

A extensão de caracteres UTF-8 para analisar.

style: NumberStyles

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

provider: IFormatProvider

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

result: Byte

No retorno, contém o resultado de uma análise utf8Text bem-sucedida ou um valor indefinido em caso de falha.

Devoluções

Boolean

true se utf8Text foi analisado com sucesso; caso contrário, false.

Aplica-se a

TryParse(ReadOnlySpan<Byte>, Byte)

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Tenta converter um intervalo de caracteres UTF-8 contendo a representação da cadeia de um número para o seu equivalente inteiro sem sinal de 8 bits.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, [Runtime::InteropServices::Out] System::Byte % result);

public static bool TryParse(ReadOnlySpan<byte> utf8Text, out byte result);

static member TryParse : ReadOnlySpan<byte> * byte -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), ByRef result As Byte) As Boolean

Parâmetros

utf8Text: ReadOnlySpan<Byte>

Um espaço contendo os caracteres UTF-8 que representam o número a converter.

result: Byte

Quando este método retorna, contém o valor inteiro sem sinal de 8 bits equivalente ao número contido em utf8Text se a conversão foi bem-sucedida, ou zero se a conversão falhou. Este parâmetro é passado sem inicializar; qualquer valor originalmente fornecido no resultado será sobrescrito.

Devoluções

Boolean

true se utf8Text foi convertido com sucesso; caso contrário, false.

Aplica-se a

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Byte)

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Converte a representação span de um número num estilo especificado e formato específico de cultura para o seu Byte equivalente. Um valor de retorno indica se a conversão teve sucesso ou falhou.

public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result) = System::Numerics::INumberBase<System::Byte>::TryParse;

public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result);

public static bool TryParse(ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider? provider, out byte result);

public static bool TryParse(ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider provider, out byte result);

static member TryParse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider * byte -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), style As NumberStyles, provider As IFormatProvider, ByRef result As Byte) As Boolean

Parâmetros

s: ReadOnlySpan<Char>

Um espaço que contém os caracteres que representam o número a converter. O vão é interpretado usando o Integer estilo.

style: NumberStyles

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

provider: IFormatProvider

Um objeto que fornece informação de formatação específica de cultura sobre s. Se provider for null, usa-se a cultura atual do fio.

result: Byte

Quando este método retorna, contém o valor inteiro sem sinal de 8 bits equivalente ao número contido em s se a conversão foi bem-sucedida, ou zero se a conversão falhou. A conversão falha se o s parâmetro for null ou Empty, não for do formato correto, ou representar um número menor que Byte.MinValue ou maior que Byte.MaxValue. Este parâmetro é passado sem inicializar; qualquer valor originalmente fornecido result será sobrescrito.

Devoluções

Boolean

true se s foi convertido com sucesso; caso contrário, false.

Aplica-se a

TryParse(String, NumberStyles, IFormatProvider, Byte)

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Converte a representação em cadeia de um número num estilo especificado e formato específico de cultura para o seu Byte equivalente. Um valor de retorno indica se a conversão teve sucesso ou falhou.

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result);

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Byte % result) = System::Numerics::INumberBase<System::Byte>::TryParse;

public static bool TryParse(string s, System.Globalization.NumberStyles style, IFormatProvider provider, out byte result);

public static bool TryParse(string? s, System.Globalization.NumberStyles style, IFormatProvider? provider, out byte result);

static member TryParse : string * System.Globalization.NumberStyles * IFormatProvider * byte -> bool

Public Shared Function TryParse (s As String, style As NumberStyles, provider As IFormatProvider, ByRef result As Byte) As Boolean

Parâmetros

s: String

Uma cadeia contendo um número a converter. A cadeia é interpretada usando o estilo especificado por style.

style: NumberStyles

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

provider: IFormatProvider

Um objeto que fornece informação de formatação específica de cultura sobre s. Se provider for null, usa-se a cultura atual do fio.

result: Byte

Devoluções

Boolean

true se s foi convertido com sucesso; caso contrário, false.

Exceções

ArgumentException

style não é um NumberStyles valor.

-ou-

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

Exemplos

O exemplo seguinte chama o TryParse(String, NumberStyles, IFormatProvider, Byte) método com vários valores de cadeia diferentes.

using System;
using System.Globalization;

public class ByteConversion2
{
   public static void Main()
   {
      string byteString;
      NumberStyles styles;

      byteString = "1024";
      styles = NumberStyles.Integer;
      CallTryParse(byteString, styles);

      byteString = "100.1";
      styles = NumberStyles.Integer | NumberStyles.AllowDecimalPoint;
      CallTryParse(byteString, styles);

      byteString = "100.0";
      CallTryParse(byteString, styles);

      byteString = "+100";
      styles = NumberStyles.Integer | NumberStyles.AllowLeadingSign
               | NumberStyles.AllowTrailingSign;
      CallTryParse(byteString, styles);

      byteString = "-100";
      CallTryParse(byteString, styles);

      byteString = "000000000000000100";
      CallTryParse(byteString, styles);

      byteString = "00,100";
      styles = NumberStyles.Integer | NumberStyles.AllowThousands;
      CallTryParse(byteString, styles);

      byteString = "2E+3   ";
      styles = NumberStyles.Integer | NumberStyles.AllowExponent;
      CallTryParse(byteString, styles);

      byteString = "FF";
      styles = NumberStyles.HexNumber;
      CallTryParse(byteString, styles);

      byteString = "0x1F";
      CallTryParse(byteString, styles);
   }

   private static void CallTryParse(string stringToConvert, NumberStyles styles)
   {
      Byte byteValue;
      bool result = Byte.TryParse(stringToConvert, styles,
                                  null as IFormatProvider, out byteValue);
      if (result)
         Console.WriteLine("Converted '{0}' to {1}",
                        stringToConvert, byteValue);
      else
         Console.WriteLine("Attempted conversion of '{0}' failed.",
                           stringToConvert.ToString());
   }
}
// The example displays the following output to the console:
//       Attempted conversion of '1024' failed.
//       Attempted conversion of '100.1' failed.
//       Converted '100.0' to 100
//       Converted '+100' to 100
//       Attempted conversion of '-100' failed.
//       Converted '000000000000000100' to 100
//       Converted '00,100' to 100
//       Attempted conversion of '2E+3   ' failed.
//       Converted 'FF' to 255
//       Attempted conversion of '0x1F' failed.

open System
open System.Globalization

let callTryParse (stringToConvert: string) (styles: NumberStyles) =
    match Byte.TryParse(stringToConvert, styles, null) with
    | true, byteValue ->
        printfn $"Converted '{stringToConvert}' to {byteValue}"
    | _ ->
        printfn $"Attempted conversion of '{stringToConvert}' failed."
                        
[<EntryPoint>]
let main _ =
    let byteString = "1024"
    let styles = NumberStyles.Integer
    callTryParse byteString styles

    let byteString = "100.1"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint
    callTryParse byteString styles

    let byteString = "100.0"
    callTryParse byteString styles

    let byteString = "+100"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowLeadingSign ||| NumberStyles.AllowTrailingSign
    callTryParse byteString styles

    let byteString = "-100"
    callTryParse byteString styles

    let byteString = "000000000000000100"
    callTryParse byteString styles

    let byteString = "00,100"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowThousands
    callTryParse byteString styles

    let byteString = "2E+3   "
    let styles = NumberStyles.Integer ||| NumberStyles.AllowExponent
    callTryParse byteString styles

    let byteString = "FF"
    let styles = NumberStyles.HexNumber
    callTryParse byteString styles

    let byteString = "0x1F"
    callTryParse byteString styles

    0

// The example displays the following output to the console:
//       Attempted conversion of '1024' failed.
//       Attempted conversion of '100.1' failed.
//       Converted '100.0' to 100
//       Converted '+100' to 100
//       Attempted conversion of '-100' failed.
//       Converted '000000000000000100' to 100
//       Converted '00,100' to 100
//       Attempted conversion of '2E+3   ' failed.
//       Converted 'FF' to 255
//       Attempted conversion of '0x1F' failed.

Imports System.Globalization

Module ByteConversion2
   Public Sub Main()
      Dim byteString As String 
      Dim styles As NumberStyles
      
      byteString = "1024"
      styles = NumberStyles.Integer
      CallTryParse(byteString, styles)
      
      byteString = "100.1"
      styles = NumberStyles.Integer Or NumberStyles.AllowDecimalPoint
      CallTryParse(byteString, styles)
      
      byteString = "100.0"
      CallTryParse(byteString, styles)
      
      byteString = "+100"
      styles = NumberStyles.Integer Or NumberStyles.AllowLeadingSign _
               Or NumberStyles.AllowTrailingSign
      CallTryParse(byteString, styles)
      
      byteString = "-100"
      CallTryParse(byteString, styles)
      
      byteString = "000000000000000100"
      CallTryParse(byteString, styles)
      
      byteString = "00,100"      
      styles = NumberStyles.Integer Or NumberStyles.AllowThousands
      CallTryParse(byteString, styles)
      
      byteString = "2E+3   "
      styles = NumberStyles.Integer Or NumberStyles.AllowExponent
      CallTryParse(byteString, styles)
      
      byteString = "FF"
      styles = NumberStyles.HexNumber
      CallTryParse(byteString, styles)
      
      byteString = "0x1F"
      CallTryParse(byteString, styles)
   End Sub
   
   Private Sub CallTryParse(stringToConvert As String, styles As NumberStyles)  
      Dim byteValue As Byte
      Dim result As Boolean = Byte.TryParse(stringToConvert, styles, Nothing, _
                                            byteValue)
      If result Then
         Console.WriteLine("Converted '{0}' to {1}", _
                        stringToConvert, byteValue)
      Else
         If stringToConvert Is Nothing Then stringToConvert = ""
         Console.WriteLine("Attempted conversion of '{0}' failed.", _
                           stringToConvert.ToString())
      End If                        
   End Sub
End Module
' The example displays the following output to the console:
'       Attempted conversion of '1024' failed.
'       Attempted conversion of '100.1' failed.
'       Converted '100.0' to 100
'       Converted '+100' to 100
'       Attempted conversion of '-100' failed.
'       Converted '000000000000000100' to 100
'       Converted '00,100' to 100
'       Attempted conversion of '2E+3   ' failed.
'       Converted 'FF' to 255
'       Attempted conversion of '0x1F' failed.

Observações

O TryParse método é semelhante ao Parse método, exceto que o TryParse método não lança uma exceção se a conversão falhar.

O s parâmetro é analisado usando a informação de formatação num NumberFormatInfo objeto fornecida pelo provider parâmetro.

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

[ws][$][signo]dígitos[.fractional_digits][e[dígitos de sinal][ws]

Ou, se o style parâmetro incluir AllowHexSpecifier:

[ws]hexdigits[ws]

Elementos entre parênteses ( [ e ] ) são opcionais. A tabela a seguir descreve cada elemento.

Elemento	Descrição
ws	Espaço em branco opcional. O espaço em branco pode aparecer no início de `s` se `style` inclui a NumberStyles.AllowLeadingWhite bandeira, ou no final de s se o estilo inclui a NumberStyles.AllowTrailingWhite bandeira.
$	Um símbolo monetário específico de cada cultura. A sua posição na cadeia é definida pela NumberFormatInfo.CurrencyPositivePattern propriedade do NumberFormatInfo objeto devolvida pelo GetFormat método do `provider` parâmetro. O símbolo da moeda pode aparecer se `sstyle` incluir a NumberStyles.AllowCurrencySymbol bandeira.
assinar	Um sinal positivo opcional. (A operação de análise falha se houver um sinal negativo em `s`.) O sinal pode aparecer no início de `s` if inclui a `style` bandeira, ou no final de NumberStyles.AllowLeadingSign if `s` inclui a `style`NumberStyles.AllowTrailingSign bandeira.
dígitos	Uma sequência de dígitos de 0 a 9.
.	Um símbolo de ponto decimal específico para cada cultura. O símbolo da vírgula decimal da cultura especificado por `provider` pode aparecer em `s` se `style` incluir a NumberStyles.AllowDecimalPoint bandeira.
fractional_digits	Uma ou mais ocorrências do dígito 0. Os dígitos fracionários só podem aparecer se `sstyle` incluir a NumberStyles.AllowDecimalPoint bandeira.
e	O carácter e ou E, que indica que o valor é representado em notação exponencial. O `s` parâmetro pode representar um número em notação exponencial se `style` incluir a NumberStyles.AllowExponent bandeira.
Hexdigits	Uma sequência de dígitos hexadecimais de 0 a f, ou de 0 a F.

Note

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

Uma cadeia apenas com dígitos decimais (que corresponde ao NumberStyles.None estilo) faz sempre análise com sucesso. A maioria dos membros restantes NumberStyles controla elementos que podem estar, mas não são obrigados a estar, nesta cadeia de entrada. A tabela seguinte indica como os membros individuais NumberStyles afetam os elementos que podem estar presentes em s.

Valores de NumberStyles não compostos	Elementos permitidos em s além dos dígitos
NumberStyles.None	Apenas dígitos decimais.
NumberStyles.AllowDecimalPoint	Os elementos . e fractional_digits. No entanto, fractional_digits deve consistir apenas em um ou mais dígitos 0, caso contrário o método devolve `false`.
NumberStyles.AllowExponent	O `s` parâmetro também pode usar notação exponencial. Se `s` representa um número em notação exponencial, deve representar um inteiro dentro do intervalo do Byte tipo de dado sem um componente fracionário não nulo.
NumberStyles.AllowLeadingWhite	O elemento ws no início de `s`.
NumberStyles.AllowTrailingWhite	O elemento ws no final de `s`.
NumberStyles.AllowLeadingSign	Um sinal positivo pode aparecer antes dos dígitos.
NumberStyles.AllowTrailingSign	Um sinal positivo pode aparecer após os dígitos.
NumberStyles.AllowParentheses	Embora este flag seja suportado, o método retorna `false` se houver parênteses em `s`.
NumberStyles.AllowThousands	Embora o símbolo do separador de grupo possa aparecer em `s`, pode ser precedido apenas por um ou mais dígitos 0.
NumberStyles.AllowCurrencySymbol	O $ elemento.

Se a NumberStyles.AllowHexSpecifier bandeira for usada, s deve ser um valor hexadecimal sem prefixo. Por exemplo, "F3" analisa com sucesso, mas "0xF3" não. As únicas outras bandeiras que podem estar presentes em style e NumberStyles.AllowLeadingWhite NumberStyles.AllowTrailingWhite. (A NumberStyles enumeração tem um estilo numérico composto, NumberStyles.HexNumber, que inclui ambas as bandeiras de espaço em branco.)

O provider parâmetro é uma IFormatProvider implementação, como um CultureInfo objeto ou um NumberFormatInfo objeto, cujo GetFormat método devolve um NumberFormatInfo objeto. O NumberFormatInfo objeto fornece informação específica da cultura sobre o formato de s.

Ver também

Aplica-se a

Comentários

Esta página foi útil?