Byte.TryParse Metoda

Definicja

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<Char>, Byte)

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

TryParse(String, IFormatProvider, Byte)

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

TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)

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

TryParse(String, Byte)

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.

TryParse(String, NumberStyles, IFormatProvider, Byte)

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.

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

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

TryParse(ReadOnlySpan<Char>, Byte)

Próbuje przekonwertować reprezentację zakresu liczby na Byte równoważną 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 przekonwertowania.

result
Byte

Gdy ta metoda zostanie zwrócona, zawiera wartość równoważną liczbie zawartej Byte w s przypadku powodzenia konwersji lub zera, jeśli konwersja nie powiodła się. 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.

Dotyczy

TryParse(String, IFormatProvider, Byte)

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

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
provider
IFormatProvider
result
Byte

Zwraca

Boolean

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

Dotyczy

TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)

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

provider
IFormatProvider
result
Byte

Zwraca

Boolean

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

Dotyczy

TryParse(String, Byte)

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.

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

Gdy ta metoda zostanie zwrócona, zawiera wartość równoważną liczbie zawartej Byte w s przypadku powodzenia konwersji lub zera, jeśli konwersja nie powiodła się. 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.

Przykłady

Poniższy przykład wywołuje metodę TryParse(String, Byte) z wieloma 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 wartość , jeśli parametr nie jest w poprawnym formacie, jeśli jest String.Emptynull lub , lub jeśli reprezentuje liczbę mniejszą niż MinValue lub większą niż MaxValue.s false

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ącym formularzu:

[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.
cyfry 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 bajtowej 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 wartość OverflowException.) Aby jawnie zdefiniować elementy stylu wraz z informacjami formatowania 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ć reprezentację ciągu szesnastkowej liczby, wywołaj Byte.TryParse(String, NumberStyles, IFormatProvider, Byte) przeciążenie.

Zobacz też

Dotyczy

TryParse(String, NumberStyles, IFormatProvider, Byte)

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.MinValue 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

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 wieloma 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 NumberFormatInfo provider 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 style``s 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łe znaki mogą 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 spliku ). 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 .
cyfry 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

Wszystkie 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 Element . i fractional_digits elementów. 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 selementu .
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 spliku , 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, styleNumberStyles.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

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

Konwertuje reprezentację zakresu 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(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 przekonwertowania. Zakres jest interpretowany przy użyciu Integer stylu.

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.MinValue 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.

Dotyczy