Byte.TryParse Methode

Definition

Namespace:: System

Assemblys:: mscorlib.dll, System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Versucht, die Zeichenfolgendarstellung einer Zahl in die Byte entsprechende Zahl zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich war.

Überlädt

Name	Beschreibung
TryParse(String, Byte)	Versucht, die Zeichenfolgendarstellung einer Zahl in die Byte entsprechende Zahl zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich war.
TryParse(ReadOnlySpan<Char>, Byte)	Versucht, die Spannweitendarstellung einer Zahl in ihr Byte Äquivalent zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich war.
TryParse(String, NumberStyles, IFormatProvider, Byte)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in das Byte entsprechende Format. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder fehlgeschlagen ist.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Byte)	Konvertiert die Spandarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in das Byte entsprechende Format. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder fehlgeschlagen ist.

TryParse(String, Byte)

Versucht, die Zeichenfolgendarstellung einer Zahl in die Byte entsprechende Zahl zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich war.

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] System::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

Parameter

s: String

Eine Zeichenfolge, die eine zahl enthält, die konvertiert werden soll.

result: Byte

Wenn diese Methode zurückgegeben wird, enthält sie den Byte Wert, der der Zahl entspricht, die enthalten s ist, wenn die Konvertierung erfolgreich war, oder null, wenn die Konvertierung fehlgeschlagen ist. Dieser Parameter wird nicht initialisiert übergeben. alle ursprünglich bereitgestellten result Werte werden überschrieben.

Gibt zurück

Boolean

true wenn s erfolgreich konvertiert wurde; andernfalls false.

Beispiele

Im folgenden Beispiel wird die TryParse(String, Byte) Methode mit einer Reihe unterschiedlicher Zeichenfolgenwerte aufgerufen.

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.

Hinweise

Die Konvertierung schlägt fehl, und die Methode gibt zurück false , wenn sich der s Parameter nicht im richtigen Format befindet, wenn er null oder String.Empty, oder wenn er eine Zahl kleiner MinValue oder größer als MaxValuedarstellt.

Die Byte.TryParse(String, Byte) Methode ähnelt der Byte.Parse(String) Methode, mit der Ausnahme, dass TryParse(String, Byte) keine Ausnahme ausgelöst wird, wenn die Konvertierung fehlschlägt.

Der s Parameter sollte die Zeichenfolgendarstellung einer Zahl in der folgenden Form sein:

[ws][sign]digits[ws]

Elemente in eckigen Klammern ([ und ]) sind optional. In der folgenden Tabelle wird jedes Element beschrieben.

Element	Description
Ws	Optionaler Leerraum.
Zeichen	Ein optionales positives Zeichen, wie durch die NumberFormatInfo.PositiveSign Eigenschaft der aktuellen Kultur angegeben.
Ziffern	Eine Abfolge von Dezimalziffern, die zwischen 0 und 9 liegen.

Der s Parameter wird mithilfe der Integer Formatvorlage interpretiert. Neben den Dezimalstellen des Bytewerts sind nur führende und nachfolgende Leerzeichen zusammen mit einem vorangestellten Zeichen zulässig. (Wenn das Zeichen vorhanden ist, muss es ein positives Zeichen sein, oder die Methode löst ein OverflowException.) Wenn Sie die Formatvorlagenelemente explizit zusammen mit den kulturspezifischen Formatierungsinformationen definieren möchten, die vorhanden ssein können, verwenden Sie die Byte.Parse(String, NumberStyles, IFormatProvider) Methode.

Der s Parameter wird mithilfe der Formatierungsinformationen in einem NumberFormatInfo Objekt für die aktuelle Kultur analysiert. Weitere Informationen finden Sie unter NumberFormatInfo.CurrentInfo.

Diese Überladung der Byte.TryParse(String, Byte) Methode interpretiert alle Ziffern im s Parameter als Dezimalziffern. Rufen Sie die Überladung auf Byte.TryParse(String, NumberStyles, IFormatProvider, Byte) , um die Zeichenfolgendarstellung einer Hexadezimalzahl zu analysieren.

Weitere Informationen

Gilt für:

TryParse(ReadOnlySpan<Char>, Byte)

Versucht, die Spannweitendarstellung einer Zahl in ihr Byte Äquivalent zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich war.

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

Parameter

s: ReadOnlySpan<Char>

Eine Spanne mit den Zeichen, die die zu konvertierende Zahl darstellen.

result: Byte

Gibt zurück

Boolean

true wenn s erfolgreich konvertiert wurde; andernfalls false.

Gilt für:

TryParse(String, NumberStyles, IFormatProvider, Byte)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in das Byte entsprechende Format. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder fehlgeschlagen ist.

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::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

Parameter

s: String

Eine Zeichenfolge, die eine zahl enthält, die konvertiert werden soll. Die Zeichenfolge wird mithilfe der durch style.

style: NumberStyles

Eine bitweise Kombination von Enumerationswerten, die die Formatvorlagenelemente angibt, in sdenen vorhanden sein kann. Ein typischer Wert, der angegeben werden soll, ist Integer.

provider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s. Ist provider dies nullder Grund, wird die aktuelle Threadkultur verwendet.

result: Byte

Wenn diese Methode zurückgegeben wird, enthält sie den 8-Bit-Ganzzahlwert ohne Vorzeichen, der der Zahl entspricht, die enthalten s ist, wenn die Konvertierung erfolgreich war, oder null, wenn die Konvertierung fehlgeschlagen ist. Die Konvertierung schlägt fehl, wenn der s Parameter nicht das richtige Format aufweist null oder Emptyeine Zahl kleiner als Byte.MinValue oder größer als Byte.MaxValue darstellt. Dieser Parameter wird nicht initialisiert übergeben. alle ursprünglich bereitgestellten result Werte werden überschrieben.

Gibt zurück

Boolean

true wenn s erfolgreich konvertiert wurde; andernfalls false.

Ausnahmen

ArgumentException

style ist kein NumberStyles Wert.

-oder-

style ist keine Kombination von AllowHexSpecifier und HexNumber Werten.

Beispiele

Im folgenden Beispiel wird die TryParse(String, NumberStyles, IFormatProvider, Byte) Methode mit einer Reihe unterschiedlicher Zeichenfolgenwerte aufgerufen.

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.

Hinweise

Die TryParse Methode ähnelt der Parse Methode, außer die TryParse Methode löst keine Ausnahme aus, wenn die Konvertierung fehlschlägt.

Der s Parameter wird mithilfe der Formatierungsinformationen in einem NumberFormatInfo objekt analysiert, das provider vom Parameter bereitgestellt wird.

Der Formatvorlagenparameter definiert die Formatvorlagenelemente (z. B. Leerzeichen oder das positive Zeichen), die im s Parameter für den erfolgreichen Analysevorgang zulässig sind. Es muss eine Kombination aus Bitkennzeichnungen aus der NumberStyles Enumeration sein. Je nach Wert kann styleder s Parameter die folgenden Elemente enthalten:

[ws][$][Sign]digits[.fractional_digits][e[sign]digits][ws]

Oder, wenn der style Parameter Folgendes enthält AllowHexSpecifier:

[ws]hexdigits[ws]

Elemente in eckigen Klammern ( [ und ] ) sind optional. In der folgenden Tabelle wird jedes Element beschrieben.

Element	Description
Ws	Optionaler Leerraum. Leerzeichen können am Anfang der `sstyle`NumberStyles.AllowLeadingWhite Kennzeichnung oder am Ende von s angezeigt werden, wenn die Formatvorlage die NumberStyles.AllowTrailingWhite Kennzeichnung enthält.
$	Ein kulturspezifisches Währungssymbol. Die Position in der Zeichenfolge wird durch die NumberFormatInfo.CurrencyPositivePattern Eigenschaft des Objekts definiert, das NumberFormatInfo von der GetFormat Methode des `provider` Parameters zurückgegeben wird. Das Währungssymbol kann angezeigt werden, wenn `s` das `style` Kennzeichen enthalten NumberStyles.AllowCurrencySymbol ist.
Zeichen	Ein optionales positives Zeichen. (Der Analysevorgang schlägt fehl, wenn ein negatives Zeichen in `s`.) Das Zeichen kann am Anfang des `s` Zeichens angezeigt werden, wenn `style` die NumberStyles.AllowLeadingSign Kennzeichnung enthalten ist, oder am Ende, `s` wenn `style` die NumberStyles.AllowTrailingSign Kennzeichnung enthalten ist.
Ziffern	Eine Sequenz von Ziffern von 0 bis 9.
.	Ein kulturspezifisches Dezimalkommasymbol. Das Dezimalkommasymbol der durch diese Kultur angegebenen `provider` Kultur kann angezeigt werden `s` , wenn `style` die NumberStyles.AllowDecimalPoint Kennzeichnung enthalten ist.
fractional_digits	Mindestens ein Vorkommen der Ziffer 0. Dezimalstellen können nur angezeigt werden `s` , wenn `style` die NumberStyles.AllowDecimalPoint Kennzeichnung enthalten ist.
e	Das E- oder E-Zeichen, das angibt, dass der Wert in exponentieller Schreibweise dargestellt wird. Der `s` Parameter kann eine Zahl in exponentieller Notation darstellen, wenn `style` das NumberStyles.AllowExponent Flag enthalten ist.
hexdigits	Eine Abfolge von hexadezimalen Ziffern von 0 bis f oder 0 bis F.

Note

Alle endenden NUL-Zeichen s (U+0000) werden unabhängig vom Wert des style Arguments vom Analysevorgang ignoriert.

Eine Zeichenfolge mit dezimalen Ziffern (die der NumberStyles.None Formatvorlage entspricht) analysiert immer erfolgreich. Die meisten der verbleibenden NumberStyles Elemente steuern Elemente, die möglicherweise vorhanden, aber nicht in dieser Eingabezeichenfolge vorhanden sein müssen. In der folgenden Tabelle wird angegeben, wie sich einzelne NumberStyles Member auf die Elemente auswirken, die möglicherweise svorhanden sind.

Nicht zusammengesetzte NumberStyles-Werte	Elemente, die zusätzlich zu Ziffern in s zulässig sind
NumberStyles.None	Nur Dezimalziffern.
NumberStyles.AllowDecimalPoint	Die Elemente . und fractional_digits . Fractional_digits darf jedoch nur aus einer oder mehreren 0 Ziffern bestehen, oder die Methode gibt zurück`false`.
NumberStyles.AllowExponent	Der `s` Parameter kann auch exponentielle Notation verwenden. Wenn `s` eine Zahl in exponentieller Schreibweise dargestellt wird, muss sie eine ganze Zahl innerhalb des Bereichs des Byte Datentyps ohne eine Nicht-Null-Bruchkomponente darstellen.
NumberStyles.AllowLeadingWhite	Das ws-Element am Anfang von `s`.
NumberStyles.AllowTrailingWhite	Das ws-Element am Ende von `s`.
NumberStyles.AllowLeadingSign	Ein positives Zeichen kann vor Ziffern angezeigt werden.
NumberStyles.AllowTrailingSign	Ein positives Zeichen kann nach Ziffern angezeigt werden.
NumberStyles.AllowParentheses	Obwohl dieses Flag unterstützt wird, gibt die Methode zurück `false` , wenn Klammern vorhanden `s`sind.
NumberStyles.AllowThousands	Obwohl das Gruppentrennzeichen in `s`angezeigt werden kann, kann es nur einer oder mehreren Ziffern vorangestellt werden.
NumberStyles.AllowCurrencySymbol	Das $ Element.

Wenn das NumberStyles.AllowHexSpecifier Flag verwendet wird, s muss es sich um einen Hexadezimalwert ohne Präfix sein. Beispielsweise analysiert "F3" erfolgreich, aber "0xF3" nicht. Die einzigen anderen Flags, die style vorhanden sein können, sind NumberStyles.AllowLeadingWhite und NumberStyles.AllowTrailingWhite. (Die NumberStyles Aufzählung weist eine zusammengesetzte Zahlenformatvorlage auf, NumberStyles.HexNumberdie beide Leerzeichen-Flags enthält.)

Der provider Parameter ist eine IFormatProvider Implementierung, z. B. ein CultureInfo Objekt oder ein NumberFormatInfo Objekt, dessen GetFormat Methode ein NumberFormatInfo Objekt zurückgibt. Das NumberFormatInfo Objekt stellt kulturspezifische Informationen zum Format von s.

Weitere Informationen

Gilt für:

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

Konvertiert die Spandarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in das Byte entsprechende Format. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder fehlgeschlagen ist.

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

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

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

Parameter

s: ReadOnlySpan<Char>

Eine Spanne mit den Zeichen, die die zu konvertierende Zahl darstellen. Die Spanne wird mithilfe der Integer Formatvorlage interpretiert.

style: NumberStyles

Eine bitweise Kombination von Enumerationswerten, die die Formatvorlagenelemente angibt, in sdenen vorhanden sein kann. Ein typischer Wert, der angegeben werden soll, ist Integer.

provider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s. Ist provider dies nullder Grund, wird die aktuelle Threadkultur verwendet.

result: Byte

Gibt zurück

Boolean

true wenn s erfolgreich konvertiert wurde; andernfalls false.

Gilt für:

Feedback

War diese Seite hilfreich?