Byte.TryParse Método

Referência

Definição

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

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

Sobrecargas

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)	Tenta analisar um intervalo de caracteres UTF-8 em um valor.
TryParse(ReadOnlySpan<Char>, Byte)	Tenta converter a representação de intervalo de um número em seu Byte equivalente e retorna um valor que indica se a conversão foi bem-sucedida.
TryParse(String, Byte)	Tenta converter a representação de cadeia de caracteres de um número em seu Byte equivalente e retorna um valor que indica se a conversão foi bem-sucedida.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)	Tenta analisar um intervalo de caracteres em um valor.
TryParse(String, IFormatProvider, Byte)	Tenta analisar uma cadeia de caracteres em um valor.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Byte)	Tenta analisar um intervalo de caracteres UTF-8 em um valor.
TryParse(ReadOnlySpan<Byte>, Byte)	Tenta converter um intervalo de caracteres UTF-8 que contém a representação de cadeia de caracteres de um número em seu inteiro sem sinal de 8 bits equivalente.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Byte)	Converte a representação de intervalo de um número com um estilo especificado e um formato específico à cultura para seu Byte equivalente. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.
TryParse(String, NumberStyles, IFormatProvider, Byte)	Converte a representação de cadeia de caracteres de um número com um estilo especificado e um formato específico à cultura para seu Byte equivalente. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)

Origem:: Byte.cs

Origem:: Byte.cs

Tenta analisar um intervalo de caracteres UTF-8 em um 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>

O intervalo de caracteres UTF-8 a serem analisados.

provider: IFormatProvider

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

result: Byte

No retorno, contém o resultado da análise utf8Text com êxito ou de um valor indefinido em caso de falha.

Retornos

Boolean

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

Aplica-se a

TryParse(ReadOnlySpan<Char>, Byte)

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Tenta converter a representação de intervalo de um número em seu Byte equivalente e retorna um valor que indica se a conversão foi bem-sucedida.

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 intervalo que contém os caracteres que representam o número a ser convertido.

result: Byte

Quando esse método retorna, ele contém o valor Byte equivalente ao número contido em s, caso a conversão seja bem-sucedida ou zero caso a conversão falhe. Este parâmetro é passado não inicializado; qualquer valor fornecido originalmente em result será substituído.

Retornos

Boolean

true caso s tenha sido convertido com êxito; do contrário, false.

Aplica-se a

TryParse(String, Byte)

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Tenta converter a representação de cadeia de caracteres de um número em seu Byte equivalente e retorna 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 de caracteres que contém um número a ser convertido.

result: Byte

Retornos

Boolean

true caso s tenha sido convertido com êxito; do contrário, false.

Exemplos

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

using namespace System;

void main()
{
   array<String^>^ byteStrings = gcnew array<String^> { nullptr, String::Empty, 
                                                        "1024", "100.1", "100", 
                                                        "+100", "-100", "000000000000000100", 
                                                        "00,100", "   20   ", "FF", "0x1F" };
   Byte byteValue;
   for each (String^ byteString in byteStrings) {
      bool result = Byte::TryParse(byteString, byteValue);
      if (result)
         Console::WriteLine("Converted '{0}' to {1}", 
                            byteString, byteValue);
      else
         Console::WriteLine("Attempted conversion of '{0}' failed.", 
                            byteString);
   }
}
// The example displays the following output:
//       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.}

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.

Comentários

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

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

O s parâmetro deve ser a representação de cadeia de caracteres de um número no seguinte formato:

[ws][sign]digits[ws]

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

Elemento	Descrição
ws	Espaço em branco opcional.
sign	Um sinal 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 parâmetro s é interpretado usando-se o estilo 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 estiver presente, ele deverá ser um sinal positivo 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 no s, use o Byte.Parse(String, NumberStyles, IFormatProvider) método .

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

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

Confira também

Aplica-se a

TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Tenta analisar um intervalo de caracteres em um 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 intervalo de caracteres a serem analisados.

provider: IFormatProvider

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

result: Byte

Quando esse método retorna, contém o resultado da análise sbem-sucedida de ou um valor indefinido em caso de falha.

Retornos

Boolean

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

Aplica-se a

TryParse(String, IFormatProvider, Byte)

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Tenta analisar uma cadeia de caracteres em um 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 cadeia de caracteres a ser analisada.

provider: IFormatProvider

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

result: Byte

Quando este método retorna, contém o resultado da análise s com êxito ou um valor indefinido em caso de falha.

Retornos

Boolean

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

Aplica-se a

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

Origem:: Byte.cs

Origem:: Byte.cs

Tenta analisar um intervalo de caracteres UTF-8 em um 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>

O intervalo de caracteres UTF-8 a serem analisados.

style: NumberStyles

Uma combinação bit a bit de estilos de número que podem estar presentes em utf8Text.

provider: IFormatProvider

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

result: Byte

No retorno, contém o resultado da análise utf8Text com êxito ou de um valor indefinido em caso de falha.

Retornos

Boolean

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

Aplica-se a

TryParse(ReadOnlySpan<Byte>, Byte)

Origem:: Byte.cs

Origem:: Byte.cs

Tenta converter um intervalo de caracteres UTF-8 que contém a representação de cadeia de caracteres de um número em seu inteiro sem sinal de 8 bits equivalente.

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 intervalo que contém os caracteres UTF-8 que representam o número a ser convertido.

result: Byte

Quando esse método for retornado, ele conterá o equivalente do valor inteiro sem sinal de 8 bits do número contido em utf8Text, se a conversão tiver sido bem-sucedida, ou zero, se a conversão tiver falhado. Este parâmetro é passado não inicializado; qualquer valor fornecido originalmente no resultado será substituído.

Retornos

Boolean

true caso utf8Text tenha sido convertido com êxito; do contrário, false.

Aplica-se a

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

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Converte a representação de intervalo de um número com um estilo especificado e um formato específico à cultura para seu Byte equivalente. Um valor retornado indica se a conversão foi bem-sucedida ou falhou.

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, [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, 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 intervalo que contém os caracteres que representam o número a ser convertido. O intervalo é interpretado usando o estilo Integer.

style: NumberStyles

Um 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 ser especificado é Integer.

provider: IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre s. Caso provider seja null, a cultura atual do thread é usada.

result: Byte

Quando esse método for retornado, ele conterá o equivalente do valor inteiro sem sinal de 8 bits do número contido em s, se a conversão tiver sido bem-sucedida, ou zero, se a conversão tiver falhado. A conversão falhará 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 não inicializado; qualquer valor fornecido originalmente em result será substituído.

Retornos

Boolean

true caso s tenha sido convertido com êxito; do contrário, false.

Aplica-se a

TryParse(String, NumberStyles, IFormatProvider, Byte)

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Converte a representação de cadeia de caracteres de um número com um estilo especificado e um formato específico à cultura para seu Byte equivalente. Um valor retornado indica se a conversão foi bem-sucedida 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 de caracteres que contém um número a ser convertido. A cadeia de caracteres é interpretada usando o estilo especificado por style.

style: NumberStyles

Um 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 ser especificado é Integer.

provider: IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre s. Caso provider seja null, a cultura atual do thread é usada.

result: Byte

Retornos

Boolean

true caso s tenha sido convertido com êxito; do contrário, false.

Exceções

ArgumentException

style não é um valor NumberStyles.

- ou -

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

Exemplos

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

using namespace System;
using namespace System::Globalization;

void CallTryParse(String^ byteString, NumberStyles styles);

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);
}

void CallTryParse(String^ stringToConvert, NumberStyles styles)
{  
   Byte byteValue;
   bool result = Byte::TryParse(stringToConvert, styles, 
                                 (IFormatProvider^) nullptr , byteValue);
   if (result)
      Console::WriteLine("Converted '{0}' to {1}", 
                     stringToConvert, byteValue);
   else
      Console::WriteLine("Attempted conversion of '{0}' failed.", 
                        stringToConvert);
}
// The example displays the following output:
//       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.}

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.

Comentários

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

O s parâmetro é analisado usando as informações de formatação em um NumberFormatInfo objeto fornecido pelo provider parâmetro .

O parâmetro style define os elementos de estilo (como espaço em branco ou o sinal positivo) que são permitidos no s parâmetro para que a operação de análise tenha êxito. Ele 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]digits][ws]

Ou, se o style parâmetro incluir AllowHexSpecifier:

[ws]hexdigits[ws]

Elementos entre colchetes ( [ 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 incluir o NumberStyles.AllowLeadingWhite sinalizador ou no final de s se o estilo incluir o NumberStyles.AllowTrailingWhite`style` sinalizador.
$	Um símbolo de moeda específico de cultura. A posição na cadeia de caracteres é definida pela propriedade NumberFormatInfo.CurrencyPositivePattern do objeto NumberFormatInfo retornado pelo método GetFormat do parâmetro `provider`. O símbolo de moeda pode ser exibido em `s` caso `style` inclua o sinalizador NumberStyles.AllowCurrencySymbol.
sign	Um sinal positivo opcional. (A operação de análise falhará se um sinal negativo estiver presente em `s`.) O sinal pode aparecer no início de `s` se incluir o NumberStyles.AllowLeadingSign sinalizador ou no final de `s` se `style` incluir o NumberStyles.AllowTrailingSign sinalizador.`style`
dígitos	Uma sequência de dígitos de 0 a 9.
.	Um símbolo de vírgula decimal específico de cultura. O símbolo da vírgula decimal da cultura especificada por `provider` pode ser exibido em `s` caso `style` inclua o sinalizador NumberStyles.AllowDecimalPoint.
Fractional_digits	Uma ou mais ocorrências de dígito 0. Os dígitos fracionários só podem ser exibidos em `s` caso `style` inclua o sinalizador NumberStyles.AllowDecimalPoint.
e	O caractere e ou E, que indica que o valor é representado em notação exponencial. O parâmetro `s` pode representar um número em notação exponencial caso `style` inclua o sinalizador NumberStyles.AllowExponent.
hexdigits	Uma sequência de dígitos hexadecimais de 0 a f ou de 0 a F.

Observação

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

Uma cadeia de caracteres apenas com dígitos decimais (que corresponde ao estilo NumberStyles.None ) sempre é analisada com êxito. A maioria dos elementos de controle dos membros NumberStyles restantes que podem estar, mas que não precisam estar presentes nessa cadeia de caracteres de entrada. A tabela a seguir indica como os membros NumberStyles individuais afetam os elementos que podem estar presentes em s.

Valores NumberStyles não compostos	Elementos permitidos em s além de dígitos
NumberStyles.None	Somente dígitos decimais.
NumberStyles.AllowDecimalPoint	Os elementos . e fractional_digits . No entanto, fractional_digits deve consistir em apenas um ou mais 0 dígitos ou o método retorna `false`.
NumberStyles.AllowExponent	O parâmetro `s` também pode usar notação exponencial. Se `s` representar um número na notação exponencial, ele deverá representar um inteiro dentro do intervalo do tipo de Byte dados sem um componente fracionário diferente de zero.
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 dígitos.
NumberStyles.AllowParentheses	Embora esse sinalizador tenha suporte, o método retornará `false` se parênteses estiverem presentes em `s`.
NumberStyles.AllowThousands	Embora o símbolo do separador de grupo possa aparecer no `s`, ele pode ser precedido por apenas um ou mais 0 dígitos.
NumberStyles.AllowCurrencySymbol	O $ elemento .

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

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

Confira também

Aplica-se a

Partilhar via

Byte.TryParse Método

Definição

Sobrecargas

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)

Parâmetros

Retornos

Aplica-se a

TryParse(ReadOnlySpan<Char>, Byte)

Parâmetros

Retornos

Aplica-se a

TryParse(String, Byte)

Parâmetros

Retornos

Exemplos

Comentários

Confira também

Aplica-se a

TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)

Parâmetros

Retornos

Aplica-se a

TryParse(String, IFormatProvider, Byte)

Parâmetros

Retornos

Aplica-se a

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

Parâmetros

Retornos

Aplica-se a

TryParse(ReadOnlySpan<Byte>, Byte)

Parâmetros

Retornos

Aplica-se a

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

Parâmetros

Retornos

Aplica-se a

TryParse(String, NumberStyles, IFormatProvider, Byte)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Recursos adicionais