Byte.TryParse Methode

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.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 deren Byte-Entsprechung zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde.

Überlädt

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)	Versucht, eine Spanne von UTF-8-Zeichen in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Char>, Byte)	Versucht, die Spannendarstellung einer Zahl in deren Byte-Entsprechung zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde.
TryParse(String, Byte)	Versucht, die Zeichenfolgendarstellung einer Zahl in deren Byte-Entsprechung zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)	Versucht, eine Spanne von Zeichen in einen Wert zu analysieren.
TryParse(String, IFormatProvider, Byte)	Versucht, eine Zeichenfolge in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Byte)	Versucht, eine Spanne von UTF-8-Zeichen in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Byte>, Byte)	Versucht, eine UTF-8-Zeichenspanne, die die Zeichenfolgendarstellung einer Zahl enthält, in die entsprechende 8-Bit-Ganzzahl ohne Vorzeichen zu konvertieren.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Byte)	Konvertiert die Spannendarstellung einer Zahl in einem angegebenen Stil und kulturabhängigen Format in das entsprechende Byte. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.
TryParse(String, NumberStyles, IFormatProvider, Byte)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und kulturabhängigen Format in das entsprechende Byte. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)

Quelle:: Byte.cs

Quelle:: Byte.cs

Versucht, eine Spanne von UTF-8-Zeichen in einen Wert zu analysieren.

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

Parameter

utf8Text: ReadOnlySpan<Byte>

Die Spanne der zu analysierenden UTF-8-Zeichen.

provider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu utf8Text bereitstellt.

result: Byte

Enthält bei rückgabe das Ergebnis der erfolgreichen Analyse oder einen nicht definierten utf8Text Wert bei Einem Fehler.

Gibt zurück

Boolean

true , wenn utf8Text erfolgreich analysiert wurde, falseandernfalls .

Gilt für:

TryParse(ReadOnlySpan<Char>, Byte)

Quelle:: Byte.cs

Quelle:: Byte.cs

Quelle:: Byte.cs

Versucht, die Spannendarstellung einer Zahl in deren Byte-Entsprechung zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde.

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>

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

result: Byte

Diese Methode gibt bei erfolgreicher Konvertierung den Byte-Wert zurück, der der in s enthaltenen Zahl entspricht, und 0 (null), wenn die Konvertierung nicht durchgeführt werden konnte. Dieser Parameter wird nicht initialisiert übergeben. Jeder Wert, der ursprünglich im bereitgestellten result überschrieben werden.

Gibt zurück

Boolean

true, wenn s erfolgreich konvertiert wurde, andernfalls false.

Gilt für:

TryParse(String, Byte)

Quelle:: Byte.cs

Quelle:: Byte.cs

Quelle:: Byte.cs

Versucht, die Zeichenfolgendarstellung einer Zahl in deren Byte-Entsprechung zu konvertieren, und gibt einen Wert zurück, der angibt, ob die Konvertierung erfolgreich durchgeführt wurde.

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

Parameter

s: String

Eine Zeichenfolge, die eine zu konvertierende Zahl enthält.

result: Byte

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 verschiedener Zeichenfolgenwerte aufgerufen.

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.

Hinweise

Die Konvertierung schlägt fehl, und die -Methode gibt zurück false , wenn der s Parameter nicht das richtige Format aufweist null , wenn er oder String.Emptyist oder eine Zahl darstellt, die kleiner MinValue oder größer als MaxValueist.

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	BESCHREIBUNG
ws	Optionaler Leerraum.
sign	Ein optionales positives Zeichen, wie durch die NumberFormatInfo.PositiveSign -Eigenschaft der aktuellen Kultur angegeben.
Zahlen	Eine Sequenz von Dezimalstellen im Bereich von 0 bis 9.

Der s Parameter wird mithilfe des Stils Integer interpretiert. Zusätzlich zu den Dezimalstellen des Bytewerts sind nur führende und nachfolgende Leerzeichen zusammen mit einem führenden Zeichen zulässig. (Wenn das Zeichen vorhanden ist, muss es ein positives Zeichen sein, oder die Methode löst einen ausOverflowException.) Verwenden Sie die -Methode, um die Stilelemente explizit zusammen mit den kulturspezifischen Formatierungsinformationen zu definieren, die Byte.Parse(String, NumberStyles, IFormatProvider) in svorhanden sein können.

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 Dezimalstellen. Rufen Sie die Überladung auf, um die Byte.TryParse(String, NumberStyles, IFormatProvider, Byte) Zeichenfolgendarstellung einer Hexadezimalzahl zu analysieren.

Weitere Informationen

Gilt für:

TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)

Quelle:: Byte.cs

Quelle:: Byte.cs

Quelle:: Byte.cs

Versucht, eine Spanne von Zeichen in einen Wert zu analysieren.

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

Parameter

s: ReadOnlySpan<Char>

Die Spanne der zu analysierenden Zeichen.

provider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt.

result: Byte

Wenn diese Methode zurückgibt, enthält das Ergebnis der erfolgreichen sAnalyse oder einen undefinierten Wert bei Einem Fehler.

Gibt zurück

Boolean

true , wenn s erfolgreich analysiert wurde, falseandernfalls .

Gilt für:

TryParse(String, IFormatProvider, Byte)

Quelle:: Byte.cs

Quelle:: Byte.cs

Quelle:: Byte.cs

Versucht, eine Zeichenfolge in einen Wert zu analysieren.

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

Parameter

s: String

Die zu analysierende Zeichenfolge.

provider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt.

result: Byte

Wenn diese Methode zurückgibt, enthält das Ergebnis der erfolgreichen s Analyse oder einen nicht definierten Wert bei Einem Fehler.

Gibt zurück

Boolean

true , wenn s erfolgreich analysiert wurde, falseandernfalls .

Gilt für:

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

Quelle:: Byte.cs

Quelle:: Byte.cs

Versucht, eine Spanne von UTF-8-Zeichen in einen Wert zu analysieren.

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

Parameter

utf8Text: ReadOnlySpan<Byte>

Die Spanne der zu analysierenden UTF-8-Zeichen.

style: NumberStyles

Eine bitweise Kombination von Zahlenformatvorlagen, die in utf8Textvorhanden sein können.

provider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu utf8Text bereitstellt.

result: Byte

Enthält bei rückgabe das Ergebnis der erfolgreichen Analyse oder einen nicht definierten utf8Text Wert bei Einem Fehler.

Gibt zurück

Boolean

true , wenn utf8Text erfolgreich analysiert wurde, falseandernfalls .

Gilt für:

TryParse(ReadOnlySpan<Byte>, Byte)

Quelle:: Byte.cs

Quelle:: Byte.cs

Versucht, eine UTF-8-Zeichenspanne, die die Zeichenfolgendarstellung einer Zahl enthält, in die entsprechende 8-Bit-Ganzzahl ohne Vorzeichen zu konvertieren.

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

Parameter

utf8Text: ReadOnlySpan<Byte>

Eine Spanne, die die UTF-8-Zeichen enthält, die die zu konvertierende Zahl darstellen.

result: Byte

Diese Methode gibt bei erfolgreicher Konvertierung den Wert der ganzen 8-Bit-Zahl ohne Vorzeichen zurück, der der Zahl in utf8Text entspricht, und 0 (null), wenn die Konvertierung nicht durchgeführt werden konnte. Dieser Parameter wird nicht initialisiert übergeben. Im Ergebnis ursprünglich übergebene Werte werden ausnahmslos überschrieben.

Gibt zurück

Boolean

true, wenn utf8Text erfolgreich konvertiert wurde, andernfalls false.

Gilt für:

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

Quelle:: Byte.cs

Quelle:: Byte.cs

Quelle:: Byte.cs

Konvertiert die Spannendarstellung einer Zahl in einem angegebenen Stil und kulturabhängigen Format in das entsprechende Byte. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.

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

Parameter

s: ReadOnlySpan<Char>

Die Spanne mit den Zeichen, die die zu konvertierende Zahl darstellen. Die Spanne wird unter Verwendung des Integer-Formats interpretiert.

style: NumberStyles

Eine bitweise Kombination von Enumerationswerten, die die Stilelemente angeben, die in s vorhanden sein können. Ein häufig angegebener Wert ist Integer.

provider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt. Wenn provider gleich null ist, wird die aktuelle Threadkultur verwendet.

result: Byte

Diese Methode gibt bei erfolgreicher Konvertierung den Wert der ganzen 8-Bit-Zahl ohne Vorzeichen zurück, der der Zahl in s entspricht, und 0 (null), wenn die Konvertierung nicht durchgeführt werden konnte. Die Konvertierung schlägt fehl, wenn der s Parameter null oder Emptyist, nicht das richtige Format aufweist oder eine Zahl kleiner als Byte.MinValue oder größer als Byte.MaxValue darstellt. Dieser Parameter wird nicht initialisiert übergeben. Jeder Wert, der ursprünglich im bereitgestellten result überschrieben werden.

Gibt zurück

Boolean

true, wenn s erfolgreich konvertiert wurde, andernfalls false.

Gilt für:

TryParse(String, NumberStyles, IFormatProvider, Byte)

Quelle:: Byte.cs

Quelle:: Byte.cs

Quelle:: Byte.cs

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und kulturabhängigen Format in das entsprechende Byte. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.

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

Parameter

s: String

Eine Zeichenfolge, die die zu konvertierende Zahl enthält. Die Zeichenfolge wird unter Verwendung des durch style angegebenen Formats interpretiert.

style: NumberStyles

Eine bitweise Kombination von Enumerationswerten, die die Stilelemente angeben, die in s vorhanden sein können. Ein häufig angegebener Wert ist Integer.

provider: IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu s bereitstellt. Wenn provider gleich null ist, wird die aktuelle Threadkultur verwendet.

result: Byte

Diese Methode gibt bei erfolgreicher Konvertierung den Wert der ganzen 8-Bit-Zahl ohne Vorzeichen zurück, der der Zahl in s entspricht, und 0 (null), wenn die Konvertierung nicht durchgeführt werden konnte. Die Konvertierung schlägt fehl, wenn der s Parameter oder Emptynicht das richtige Format aufweist null oder eine Zahl kleiner als Byte.MinValue oder größer als Byte.MaxValue darstellt. Dieser Parameter wird nicht initialisiert übergeben. Jeder Wert, der ursprünglich im bereitgestellten result überschrieben werden.

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 verschiedener Zeichenfolgenwerte aufgerufen.

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.

Hinweise

Die TryParse -Methode ähnelt der Parse -Methode, aber die TryParse -Methode löst keine Ausnahme aus, wenn bei der Konvertierung ein Fehler auftritt.

Der s Parameter wird mithilfe der Formatierungsinformationen in einem NumberFormatInfo vom provider Parameter bereitgestellten Objekt analysiert.

Der Formatvorlagenparameter definiert die Stilelemente (z. B. Leerzeichen oder positives Vorzeichen), die s im Parameter zulässig sind, damit der Analysevorgang erfolgreich ausgeführt werden kann. Es muss sich um eine Kombination von Bitflags aus der NumberStyles Enumeration handeln. Abhängig vom Wert von stylekann der 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	BESCHREIBUNG
ws	Optionaler Leerraum. Leerzeichen können am Anfang von `s` angezeigt werden, wenn `style` das NumberStyles.AllowLeadingWhite Flag enthalten ist, oder am Ende von s, wenn die Formatvorlage das NumberStyles.AllowTrailingWhite Flag enthält.
$	Ein kulturspezifisches Währungssymbol. Seine 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 in `s` angezeigt werden, wenn `style` das NumberStyles.AllowCurrencySymbol Flag enthalten ist.
sign	Ein optionales positives Zeichen. (Der Analysevorgang schlägt fehl, wenn in `s`ein negatives Vorzeichen vorhanden ist.) Das Zeichen kann am Anfang von `s` angezeigt werden, wenn `style` das NumberStyles.AllowLeadingSign Flag enthalten ist, oder am Ende von `s` , wenn `style` das NumberStyles.AllowTrailingSign Flag enthalten ist.
Zahlen	Eine Sequenz von Ziffern von 0 bis 9.
.	Ein kulturspezifisches Dezimalzeichensymbol. Das Dezimalstellensymbol der durch `provider` angegebenen Kultur kann in `s` angezeigt werden, wenn `style` das NumberStyles.AllowDecimalPoint Flag enthalten ist.
fractional_digits	Mindestens ein Vorkommen der Ziffer 0. Bruchstellen können nur in `s` angezeigt werden, wenn `style` das NumberStyles.AllowDecimalPoint Flag enthalten ist.
e	Das Zeichen e oder E, das angibt, dass der Wert in exponentieller Notation dargestellt wird. Der `s` Parameter kann eine Zahl in exponentieller Notation darstellen, wenn `style` das NumberStyles.AllowExponent Flag enthalten ist.
hexdigits	Eine Sequenz von Hexadezimalstellen von 0 bis f oder 0 bis F.

Hinweis

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

Eine Zeichenfolge nur mit Dezimalstellen (die dem NumberStyles.None Format entspricht) analysiert immer erfolgreich. Die meisten der verbleibenden NumberStyles Member-Steuerelementelemente, die in dieser Eingabezeichenfolge möglicherweise vorhanden sein müssen, aber nicht erforderlich sind. Die folgende Tabelle gibt an, wie sich einzelne NumberStyles Member auf die Elemente auswirken, die möglicherweise in svorhanden sind.

Nicht zusammengesetzte NumberStyles-Werte	Zusätzlich zu Ziffern zulässige Elemente in s
NumberStyles.None	Nur Dezimalstellen.
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 die exponentielle Notation verwenden. Wenn `s` eine Zahl in exponentieller Notation darstellt, muss sie eine ganze Zahl innerhalb des Bereichs des Byte Datentyps ohne eine Ungleich-Null-Bruchkomponente darstellen.
NumberStyles.AllowLeadingWhite	Das ws-Element am Anfang von `s`.
NumberStyles.AllowTrailingWhite	Das ws-Element am Ende von `s`.
NumberStyles.AllowLeadingSign	Vor Ziffern kann ein positives Zeichen angezeigt werden.
NumberStyles.AllowTrailingSign	Nach Ziffern kann ein positives Zeichen angezeigt werden.
NumberStyles.AllowParentheses	Obwohl dieses Flag unterstützt wird, gibt die Methode zurück `false` , wenn in `s`Klammern vorhanden sind.
NumberStyles.AllowThousands	Obwohl das Gruppentrennzeichenzeichen in `s`angezeigt werden kann, kann es nur durch eine oder mehrere 0 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, "0xF3" nicht. Die einzigen anderen Flags, die in style vorhanden sein können, sind NumberStyles.AllowLeadingWhite und NumberStyles.AllowTrailingWhite. (Die NumberStyles Enumeration weist eine zusammengesetzte Zahlenart auf, NumberStyles.HexNumberdie beide Leerzeichenflags enthält.)

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

Weitere Informationen

Gilt für:

Freigeben über

Byte.TryParse Methode

Definition

Überlädt

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Byte)

Parameter

Gibt zurück

Gilt für:

TryParse(ReadOnlySpan<Char>, Byte)

Parameter

Gibt zurück

Gilt für:

TryParse(String, Byte)

Parameter

Gibt zurück

Beispiele

Hinweise

Weitere Informationen

Gilt für:

TryParse(ReadOnlySpan<Char>, IFormatProvider, Byte)

Parameter

Gibt zurück

Gilt für:

TryParse(String, IFormatProvider, Byte)

Parameter

Gibt zurück

Gilt für:

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

Parameter

Gibt zurück

Gilt für:

TryParse(ReadOnlySpan<Byte>, Byte)

Parameter

Gibt zurück

Gilt für:

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

Parameter

Gibt zurück

Gilt für:

TryParse(String, NumberStyles, IFormatProvider, Byte)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Zusätzliche Ressourcen