Byte.TryParse Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System

Zestaw:: System.Runtime.dll

Zestaw:: netstandard.dll

Zestaw:: mscorlib.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Próbuje przekonwertować reprezentację ciągu liczby na Byte równoważną i zwraca wartość wskazującą, czy konwersja zakończyła się pomyślnie.

Przeciążenia

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)	Próbuje przeanalizować zakres znaków UTF-8 w wartości.
TryParse(ReadOnlySpan<Char>, Byte)	Próbuje przekonwertować reprezentację zakresu liczby na równoważną Byte i zwraca wartość wskazującą, czy konwersja zakończyła się pomyślnie.
TryParse(String, Byte)	Próbuje przekonwertować reprezentację ciągu liczby na jej Byte odpowiednik i zwraca wartość wskazującą, czy konwersja powiodła się.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)	Próbuje przeanalizować zakres znaków w wartości.
TryParse(String, IFormatProvider, Byte)	Próbuje przeanalizować ciąg w wartości.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Byte)	Próbuje przeanalizować zakres znaków UTF-8 w wartości.
TryParse(ReadOnlySpan<Byte>, Byte)	Próbuje przekonwertować zakres znaków UTF-8 zawierający reprezentację ciągu liczby na 8-bitową liczbę całkowitą bez znaku.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Byte)	Konwertuje reprezentację zakresu liczby w określonym stylu i formacie specyficznym dla kultury na jego Byte odpowiednik. Zwracana wartość wskazuje, czy konwersja powiodła się czy nie.
TryParse(String, NumberStyles, IFormatProvider, Byte)	Konwertuje reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na jego Byte odpowiednik. Zwracana wartość wskazuje, czy konwersja powiodła się czy nie.

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)

Źródło:: Byte.cs

Źródło:: Byte.cs

Próbuje przeanalizować zakres znaków UTF-8 w wartości.

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

Parametry

utf8Text: ReadOnlySpan<Byte>

Zakres znaków UTF-8 do analizy.

provider: IFormatProvider

Obiekt, który udostępnia informacje o formatowaniu specyficznym dla kultury.utf8Text

result: Byte

Po powrocie utf8Text zawiera wynik pomyślnego analizowania lub niezdefiniowanej wartości w przypadku błędu.

Zwraca

Boolean

truejeśli utf8Text została pomyślnie przeanalizowana; w przeciwnym razie . false

Dotyczy

TryParse(ReadOnlySpan<Char>, Byte)

Źródło:: Byte.cs

Źródło:: Byte.cs

Źródło:: Byte.cs

Próbuje przekonwertować reprezentację zakresu liczby na równoważną Byte i zwraca wartość wskazującą, czy konwersja zakończyła się pomyślnie.

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

Parametry

s: ReadOnlySpan<Char>

Zakres zawierający znaki reprezentujące liczbę do konwersji.

result: Byte

Gdy ta metoda zwraca wartość równoważną Byte liczbie zawartej w s , jeśli konwersja powiodła się lub zero, jeśli konwersja nie powiodła się. Ten parametr jest przekazywany niezainicjowany; każda wartość pierwotnie podana w result zostanie zastąpiona.

Zwraca

Boolean

truejeśli s pomyślnie przekonwertowano; w przeciwnym razie . false

Dotyczy

TryParse(String, Byte)

Źródło:: Byte.cs

Źródło:: Byte.cs

Źródło:: Byte.cs

Próbuje przekonwertować reprezentację ciągu liczby na jej Byte odpowiednik i zwraca wartość wskazującą, czy konwersja powiodła się.

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

Parametry

s: String

Ciąg zawierający liczbę, którą należy przekształcić.

result: Byte

Zwraca

Boolean

truejeśli s pomyślnie przekonwertowano; w przeciwnym razie . false

Przykłady

Poniższy przykład wywołuje metodę TryParse(String, Byte) z kilkoma różnymi wartościami ciągów.

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.

Uwagi

Konwersja kończy się niepowodzeniem, a metoda zwraca false wartość , jeśli s parametr nie ma poprawnego formatu, jeśli jest String.Emptynull lub , lub jeśli reprezentuje liczbę mniejszą niż MinValue lub większą niż MaxValue.

Metoda jest podobna Byte.TryParse(String, Byte) do Byte.Parse(String) metody , z tą różnicą, że TryParse(String, Byte) nie zgłasza wyjątku w przypadku niepowodzenia konwersji.

Parametr s powinien być reprezentacją ciągu liczby w następującej postaci:

[ws][sign]digits[ws]

Elementy w nawiasach kwadratowych ([ i ]) są opcjonalne. W tabeli poniżej opisano każdy element.

Element	Opis
Ws	Opcjonalny odstęp.
sign	Opcjonalny znak dodatni określony przez NumberFormatInfo.PositiveSign właściwość bieżącej kultury.
Cyfr	Sekwencja cyfr dziesiętnych z zakresu od 0 do 9.

Parametr s jest interpretowany przy użyciu Integer stylu. Oprócz cyfr dziesiętnych wartości bajtów dozwolone są tylko spacje wiodące i końcowe wraz z znakiem wiodącym. (Jeśli znak jest obecny, musi to być znak dodatni lub metoda zgłasza OverflowExceptionznak ).) Aby jawnie zdefiniować elementy stylu wraz z informacjami o formatowaniu specyficznymi dla kultury, które mogą być obecne w sprogramie , użyj Byte.Parse(String, NumberStyles, IFormatProvider) metody .

Parametr s jest analizowany przy użyciu informacji o formatowaniu w NumberFormatInfo obiekcie dla bieżącej kultury. Aby uzyskać więcej informacji, zobacz NumberFormatInfo.CurrentInfo.

To przeciążenie Byte.TryParse(String, Byte) metody interpretuje wszystkie cyfry w parametrze s jako cyfry dziesiętne. Aby przeanalizować ciąg reprezentujący liczbę szesnastkową, wywołaj Byte.TryParse(String, NumberStyles, IFormatProvider, Byte) przeciążenie.

Zobacz też

Dotyczy

TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)

Źródło:: Byte.cs

Źródło:: Byte.cs

Źródło:: Byte.cs

Próbuje przeanalizować zakres znaków w wartości.

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

Parametry

s: ReadOnlySpan<Char>

Zakres znaków do przeanalizowania.

provider: IFormatProvider

Obiekt, który udostępnia informacje o formatowaniu specyficznym dla kultury.s

result: Byte

Gdy ta metoda zwraca wartość , zawiera wynik pomyślnej analizy s, lub niezdefiniowanej wartości w przypadku błędu.

Zwraca

Boolean

truejeśli s została pomyślnie przeanalizowana; w przeciwnym razie . false

Dotyczy

TryParse(String, IFormatProvider, Byte)

Źródło:: Byte.cs

Źródło:: Byte.cs

Źródło:: Byte.cs

Próbuje przeanalizować ciąg w wartości.

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

Parametry

s: String

Ciąg do analizy.

provider: IFormatProvider

Obiekt, który udostępnia informacje o formatowaniu specyficznym dla kultury.s

result: Byte

Gdy ta metoda zwraca wartość , zawiera wynik pomyślnej analizy s lub niezdefiniowanej wartości w przypadku błędu.

Zwraca

Boolean

truejeśli s została pomyślnie przeanalizowana; w przeciwnym razie . false

Dotyczy

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

Źródło:: Byte.cs

Źródło:: Byte.cs

Próbuje przeanalizować zakres znaków UTF-8 w wartości.

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

Parametry

utf8Text: ReadOnlySpan<Byte>

Zakres znaków UTF-8 do analizy.

style: NumberStyles

Bitowa kombinacja stylów liczbowych, które mogą być obecne w .utf8Text

provider: IFormatProvider

Obiekt, który udostępnia informacje o formatowaniu specyficznym dla kultury.utf8Text

result: Byte

Po powrocie utf8Text zawiera wynik pomyślnego analizowania lub niezdefiniowanej wartości w przypadku błędu.

Zwraca

Boolean

truejeśli utf8Text została pomyślnie przeanalizowana; w przeciwnym razie . false

Dotyczy

TryParse(ReadOnlySpan<Byte>, Byte)

Źródło:: Byte.cs

Źródło:: Byte.cs

Próbuje przekonwertować zakres znaków UTF-8 zawierający reprezentację ciągu liczby na 8-bitową liczbę całkowitą bez znaku.

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

Parametry

utf8Text: ReadOnlySpan<Byte>

Zakres zawierający znaki UTF-8 reprezentujące liczbę do konwersji.

result: Byte

Gdy ta metoda zwraca wartość , zawiera 8-bitową niepodpisaną liczbę całkowitą równoważną liczbie zawartej w utf8Text liczbie, jeśli konwersja powiodła się lub zero, jeśli konwersja nie powiodła się. Ten parametr jest przekazywany niezainicjowany; każda wartość pierwotnie podana w wyniku zostanie zastąpiona.

Zwraca

Boolean

truejeśli utf8Text pomyślnie przekonwertowano; w przeciwnym razie . false

Dotyczy

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

Źródło:: Byte.cs

Źródło:: Byte.cs

Źródło:: Byte.cs

Konwertuje reprezentację zakresu liczby w określonym stylu i formacie specyficznym dla kultury na jego Byte odpowiednik. Zwracana wartość wskazuje, czy konwersja powiodła się czy nie.

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

Parametry

s: ReadOnlySpan<Char>

Zakres zawierający znaki reprezentujące liczbę do konwersji. Zakres jest interpretowany przy użyciu Integer stylu.

style: NumberStyles

Bitowa kombinacja wartości wyliczenia wskazująca elementy stylu, które mogą być obecne w obiekcie s. Typową wartością do określenia jest Integer.

provider: IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficznym dla kultury.s Jeśli provider parametr ma nullwartość , używana jest bieżąca kultura wątku.

result: Byte

Gdy ta metoda zwraca wartość , zawiera 8-bitową niepodpisaną liczbę całkowitą równoważną liczbie zawartej w s liczbie, jeśli konwersja powiodła się lub zero, jeśli konwersja nie powiodła się. Konwersja kończy się niepowodzeniem, jeśli s parametr ma null wartość lub Empty, nie ma poprawnego formatu lub reprezentuje liczbę mniejszą niż Byte.MinValue lub większą niż Byte.MaxValue. Ten parametr jest przekazywany niezainicjowany; każda wartość pierwotnie podana w result zostanie zastąpiona.

Zwraca

Boolean

truejeśli s pomyślnie przekonwertowano; w przeciwnym razie . false

Dotyczy

TryParse(String, NumberStyles, IFormatProvider, Byte)

Źródło:: Byte.cs

Źródło:: Byte.cs

Źródło:: Byte.cs

Konwertuje reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na Byte jego odpowiednik. Zwracana wartość wskazuje, czy konwersja powiodła się czy nie.

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

Parametry

s: String

Ciąg zawierający liczbę, która ma zostać przekształcona. Ciąg jest interpretowany przy użyciu stylu określonego przez style.

style: NumberStyles

Bitowa kombinacja wartości wyliczenia, która wskazuje elementy stylu, które mogą być obecne w obiekcie s. Typową wartością do określenia jest Integer.

provider: IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficznym dla kultury.s Jeśli provider jest to null, używana jest bieżąca kultura wątku.

result: Byte

Gdy ta metoda zostanie zwrócona, zawiera 8-bitową niepodpisaną wartość całkowitą równoważną liczbie zawartej w s przypadku pomyślnej konwersji lub zero, jeśli konwersja nie powiodła się. Konwersja kończy się niepowodzeniem, jeśli s parametr ma null wartość lub Empty, nie ma poprawnego formatu lub reprezentuje liczbę mniejszą niż Byte.MinValue lub większą niż Byte.MaxValue. Ten parametr jest przekazywany jako niezainicjowany; każda wartość pierwotnie dostarczona w pliku result zostanie zastąpiona.

Zwraca

Boolean

true jeśli s pomyślnie została przekonwertowana; w przeciwnym razie false.

Wyjątki

ArgumentException

style nie jest wartością NumberStyles .

-lub-

style nie jest kombinacją AllowHexSpecifier wartości i HexNumber .

Przykłady

Poniższy przykład wywołuje metodę TryParse(String, NumberStyles, IFormatProvider, Byte) z kilkoma różnymi wartościami ciągów.

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.

Uwagi

Metoda jest podobna TryParse do Parse metody, z wyjątkiem TryParse metody nie zgłasza wyjątku, jeśli konwersja nie powiedzie się.

Parametr s jest analizowany przy użyciu informacji o formatowaniu w obiekcie dostarczonym NumberFormatInfoprovider przez parametr .

Parametr stylu definiuje elementy stylu (takie jak biały znak lub znak dodatni), które są dozwolone w parametrze s operacji analizowania, aby operacja analizy zakończyła się pomyślnie. Musi być kombinacją flag bitowych z wyliczenia NumberStyles . W zależności od wartości parametr może styles zawierać następujące elementy:

[ws] [$] [znak]cyfry[.fractional_digits][e[znak]cyfry][ws]

Lub, jeśli style parametr zawiera AllowHexSpecifier:

[odstęp]cyfry_szesnastkowe[odstęp]

Elementy w nawiasach kwadratowych ( [ i ] ) są opcjonalne. W tabeli poniżej opisano każdy element.

Element	Opis
Ws	Opcjonalny odstęp. Biały odstęp może pojawić się na początku `s` , jeśli `style` zawiera flagę NumberStyles.AllowLeadingWhite lub na końcu s, jeśli styl zawiera flagę NumberStyles.AllowTrailingWhite .
$	Symbol waluty specyficzny dla kultury. Jego pozycja w ciągu jest definiowana przez NumberFormatInfo.CurrencyPositivePattern właściwość NumberFormatInfo obiektu zwróconego przez GetFormat metodę parametru `provider` . Symbol waluty może pojawić się, `s` jeśli `style` zawiera flagę NumberStyles.AllowCurrencySymbol .
sign	Opcjonalny znak wartości dodatnich. (Operacja analizy kończy się niepowodzeniem, jeśli znak ujemny jest obecny w `s`pliku ). Znak może pojawić się na początku, `s` jeśli `style` zawiera flagę NumberStyles.AllowLeadingSign lub na końcu `s` , jeśli `style` zawiera flagę NumberStyles.AllowTrailingSign .
Cyfr	Sekwencja cyfr od 0 do 9.
.	Symbol dziesiętny specyficzny dla kultury. Symbol punktu dziesiętnego kultury określonej przez `provider` może pojawić się, `s` jeśli `style` zawiera flagę NumberStyles.AllowDecimalPoint .
fractional_digits	Jedno lub więcej wystąpień cyfry 0. Cyfry ułamkowe mogą być wyświetlane tylko wtedy `s` , gdy `style` zawiera flagę NumberStyles.AllowDecimalPoint .
E	Znak e lub E, który wskazuje, że wartość jest reprezentowana w notacji wykładniczej. Parametr `s` może reprezentować liczbę w notacji wykładniczej, jeśli `style` zawiera flagę NumberStyles.AllowExponent .
hexdigits	Sekwencja cyfr szesnastkowych od 0 do f lub od 0 do F.

Uwaga

Wszelkie znaki zakończenia NUL (U+0000) w obiekcie s są ignorowane przez operację analizowania, niezależnie od wartości argumentu style .

Ciąg z cyframi dziesiętnymi (który odpowiada NumberStyles.None stylowi) zawsze analizuje się pomyślnie. Większość pozostałych NumberStyles elementów członkowskich kontroluje elementy, które mogą być, ale nie muszą być obecne w tym ciągu wejściowym. Poniższa tabela wskazuje, jak poszczególne NumberStyles elementy członkowskie wpływają na elementy, które mogą być obecne w elemecie s.

Niezłożone wartości wyliczenia NumberStyles	Dodatkowe (poza cyframi) elementy dozwolone w parametrze s
NumberStyles.None	Tylko cyfry dziesiętne.
NumberStyles.AllowDecimalPoint	Elementy . i fractional_digits . Jednak fractional_digits musi składać się tylko z co najmniej jednej cyfry lub metody zwraca wartość `false`.
NumberStyles.AllowExponent	Parametr `s` może również używać notacji wykładniczej. Jeśli `s` reprezentuje liczbę w notacji wykładniczej, musi reprezentować liczbę całkowitą w zakresie Byte typu danych bez składnika ułamkowego bez zera.
NumberStyles.AllowLeadingWhite	Element ws na początku `s`.
NumberStyles.AllowTrailingWhite	Element ws na końcu `s`elementu .
NumberStyles.AllowLeadingSign	Znak dodatni może pojawić się przed cyframi.
NumberStyles.AllowTrailingSign	Znak dodatni może pojawić się po cyfrach.
NumberStyles.AllowParentheses	Mimo że ta flaga jest obsługiwana, metoda zwraca `false` wartość , jeśli nawiasy znajdują się w elemecie `s`.
NumberStyles.AllowThousands	Chociaż symbol separatora grup może być wyświetlany w `s`pliku , może być poprzedzony tylko jedną lub większą 0 cyframi.
NumberStyles.AllowCurrencySymbol	Element $ .

Jeśli flaga NumberStyles.AllowHexSpecifier jest używana, s musi być wartością szesnastkową bez prefiksu. Na przykład "F3" analizuje się pomyślnie, ale "0xF3" nie. Jedynymi innymi flagami, które mogą być obecne, style są NumberStyles.AllowLeadingWhite i NumberStyles.AllowTrailingWhite. (Wyliczenie NumberStyles ma styl liczb złożony, NumberStyles.HexNumber, który zawiera obie flagi odstępu).

Parametr provider jest implementacją IFormatProvider , taką jak CultureInfo obiekt lub NumberFormatInfo obiekt, którego GetFormat metoda zwraca NumberFormatInfo obiekt. Obiekt NumberFormatInfo udostępnia informacje specyficzne dla kultury dotyczące formatu .s

Zobacz też

Dotyczy

Udostępnij za pośrednictwem

Byte.TryParse Metoda

Definicja

Przeciążenia

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)

Parametry

Zwraca

Dotyczy

TryParse(ReadOnlySpan<Char>, Byte)

Parametry

Zwraca

Dotyczy

TryParse(String, Byte)

Parametry

Zwraca

Przykłady

Uwagi

Zobacz też

Dotyczy

TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)

Parametry

Zwraca

Dotyczy

TryParse(String, IFormatProvider, Byte)

Parametry

Zwraca

Dotyczy

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

Parametry

Zwraca

Dotyczy

TryParse(ReadOnlySpan<Byte>, Byte)

Parametry

Zwraca

Dotyczy

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

Parametry

Zwraca

Dotyczy

TryParse(String, NumberStyles, IFormatProvider, Byte)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Opinia

Dodatkowe zasoby