SByte.Parse Methode

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Konvertiert die Zeichenfolgendarstellung einer Zahl in die 8-Bit-ganzzahlige Entsprechung mit Vorzeichen.

Überlädt

Parse(String, NumberStyles, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl, die sich in einer angegebenen Formatvorlage und einem kulturspezifischen Format befindet, in dessen 8-Bit-Äquivalent.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konvertiert die Spandarstellung einer Zahl, die sich in einem angegebenen Format und einem kulturspezifischen Format befindet, in sein 8-Bit-Äquivalent.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analysiert eine Spanne von UTF-8 Zeichen in einen Wert.
Parse(String, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in dessen 8-Bit-Ganzzahläquivalent.
Parse(String)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die 8-Bit-ganzzahlige Entsprechung mit Vorzeichen.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analysiert eine Spanne von Zeichen in einen Wert.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analysiert eine Spanne von UTF-8 Zeichen in einen Wert.
Parse(String, NumberStyles)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage in die 8-Bit-ganzzahlige Entsprechung mit Vorzeichen.

Parse(String, NumberStyles, IFormatProvider)

Quelle:

SByte.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative

System.Int16.Parse(String, NumberStyles, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl, die sich in einer angegebenen Formatvorlage und einem kulturspezifischen Format befindet, in dessen 8-Bit-Äquivalent.

public:
 static System::SByte Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<System::SByte>::Parse;

public static sbyte Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);

static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> sbyte

Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As SByte

Parameter

s

String

Eine Zeichenfolge, die die zu konvertierende Zahl enthält. Die Zeichenfolge wird mithilfe der von styleangegebenen Formatvorlage interpretiert.

style

NumberStyles

Eine bitweise Kombination der Enumerationswerte, die die Formatvorlagenelemente angibt, die in svorhanden sein können. Ein typischer Wert, der angegeben werden soll, ist Integer.

provider

IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu sbereitstellt. Wenn providernullist, wird die aktuelle Threadkultur verwendet.

Gibt zurück

SByte

Ein 8-Bit-Bytewert, der der im s-Parameter angegebenen Zahl entspricht.

Implementiert

Parse(String, NumberStyles, IFormatProvider)

Ausnahmen

ArgumentException

style ist kein NumberStyles Wert.

-oder-

style ist keine Kombination aus AllowHexSpecifier und HexNumber.

ArgumentNullException

s ist null.

FormatException

s ist nicht in einem Format vorhanden, das mit stylekompatibel ist.

OverflowException

s stellt eine Zahl dar, die kleiner als SByte.MinValue oder größer als SByte.MaxValue-ist.

-oder-

s enthält Nicht-Null-Dezimalstellen.

Beispiele

Im folgenden Beispiel wird die Verwendung der Parse(String, NumberStyles, IFormatProvider)-Methode veranschaulicht, um verschiedene Zeichenfolgendarstellungen von Zahlen in signierte ganzzahlige Werte zu konvertieren.

using System;
using System.Globalization;

public class SByteConversion
{
   NumberFormatInfo provider = NumberFormatInfo.CurrentInfo;

   public static void Main()
   {
      string stringValue;
      NumberStyles style;

      stringValue = "   123   ";
      style = NumberStyles.None;     
      CallParseOperation(stringValue, style);
      
      stringValue = "000,000,123";
      style = NumberStyles.Integer | NumberStyles.AllowThousands;
      CallParseOperation(stringValue, style);
      
      stringValue = "-100";
      style = NumberStyles.AllowLeadingSign;
      CallParseOperation(stringValue, style);
      
      stringValue = "100-";
      style = NumberStyles.AllowLeadingSign;
      CallParseOperation(stringValue, style);
      
      stringValue = "100-";
      style = NumberStyles.AllowTrailingSign;
      CallParseOperation(stringValue, style);
      
      stringValue = "$100";
      style = NumberStyles.AllowCurrencySymbol;
      CallParseOperation(stringValue, style);
      
      style = NumberStyles.Integer;
      CallParseOperation(stringValue, style);
      
      style = NumberStyles.AllowDecimalPoint;
      CallParseOperation("100.0", style);
      
      stringValue = "1e02";
      style = NumberStyles.AllowExponent;
      CallParseOperation(stringValue, style);
      
      stringValue = "(100)";
      style = NumberStyles.AllowParentheses;
      CallParseOperation(stringValue, style);
   }
   
   private static void CallParseOperation(string stringValue, 
                                          NumberStyles style)
   {                                          
      sbyte number;
      
      if (stringValue == null)
         Console.WriteLine("Cannot parse a null string...");
         
      try
      {
         number = sbyte.Parse(stringValue, style);
         Console.WriteLine("SByte.Parse('{0}', {1})) = {2}", 
                           stringValue, style, number);   
      }
      catch (FormatException)
      {
         Console.WriteLine("'{0}' and {1} throw a FormatException", 
                           stringValue, style);   
      }      
      catch (OverflowException)
      {
         Console.WriteLine("'{0}' is outside the range of a signed byte",
                           stringValue);
      }
   }
}
// The example displays the following information to the console:
//       '   123   ' and None throw a FormatException
//       SByte.Parse('000,000,123', Integer, AllowThousands)) = 123
//       SByte.Parse('-100', AllowLeadingSign)) = -100
//       '100-' and AllowLeadingSign throw a FormatException
//       SByte.Parse('100-', AllowTrailingSign)) = -100
//       SByte.Parse('$100', AllowCurrencySymbol)) = 100
//       '$100' and Integer throw a FormatException
//       SByte.Parse('100.0', AllowDecimalPoint)) = 100
//       SByte.Parse('1e02', AllowExponent)) = 100
//       SByte.Parse('(100)', AllowParentheses)) = -100

open System
open System.Globalization

let provider = NumberFormatInfo.CurrentInfo
   
let callParseOperation stringValue (style: NumberStyles) =
    if stringValue = null then
        printfn "Cannot parse a null string..."
    else
        try
            let number = SByte.Parse(stringValue, style)
            printfn $"SByte.Parse('{stringValue}', {style})) = {number}" 
        with
        | :? FormatException ->
            printfn $"'{stringValue}' and {style} throw a FormatException"
        | :? OverflowException ->
            printfn $"'{stringValue}' is outside the range of a signed byte"

[<EntryPoint>]
let main _ =
    let stringValue = "   123   "
    let style = NumberStyles.None     
    callParseOperation stringValue style
    
    let stringValue = "000,000,123"
    let style = NumberStyles.Integer ||| NumberStyles.AllowThousands
    callParseOperation stringValue style
    
    let stringValue = "-100"
    let style = NumberStyles.AllowLeadingSign
    callParseOperation stringValue style
    
    let stringValue = "100-"
    let style = NumberStyles.AllowLeadingSign
    callParseOperation stringValue style
    
    let stringValue = "100-"
    let style = NumberStyles.AllowTrailingSign
    callParseOperation stringValue style
    
    let stringValue = "$100"
    let style = NumberStyles.AllowCurrencySymbol
    callParseOperation stringValue style
    
    let style = NumberStyles.Integer
    callParseOperation stringValue style
    
    let style = NumberStyles.AllowDecimalPoint
    callParseOperation "100.0" style
    
    let stringValue = "1e02"
    let style = NumberStyles.AllowExponent
    callParseOperation stringValue style
    
    let stringValue = "(100)"
    let style = NumberStyles.AllowParentheses
    callParseOperation stringValue style
    0

// The example displays the following information to the console:
//       '   123   ' and None throw a FormatException
//       SByte.Parse('000,000,123', Integer, AllowThousands)) = 123
//       SByte.Parse('-100', AllowLeadingSign)) = -100
//       '100-' and AllowLeadingSign throw a FormatException
//       SByte.Parse('100-', AllowTrailingSign)) = -100
//       SByte.Parse('$100', AllowCurrencySymbol)) = 100
//       '$100' and Integer throw a FormatException
//       SByte.Parse('100.0', AllowDecimalPoint)) = 100
//       SByte.Parse('1e02', AllowExponent)) = 100
//       SByte.Parse('(100)', AllowParentheses)) = -100

Imports System.Globalization

Module modMain
   Public Sub Main()
      Dim byteString As String 
      
      byteString = " 123"
      ParseString(byteString, NumberStyles.None)
      ParseString(byteString, NumberStyles.Integer)
      
      byteString = "3A"
      ParseString(byteString, NumberStyles.AllowHexSpecifier) 
      
      byteString = "21"
      ParseString(byteString, NumberStyles.Integer)
      ParseString(byteString, NumberStyles.AllowHexSpecifier)
      
      byteString = "-22"
      ParseString(byteString, NumberStyles.Integer)
      ParseString(byteString, NumberStyles.AllowParentheses)
      
      byteString = "(45)"
      ParseString(byteString, NumberStyles.AllowParentheses)
     
      byteString = "000,000,056"
      ParseString(byteString, NumberStyles.Integer)
      ParseString(byteString, NumberStyles.Integer Or NumberStyles.AllowThousands)
   End Sub
   
   Private Sub ParseString(value As String, style As NumberStyles)
      Dim number As SByte
      
      If value Is Nothing Then Console.WriteLine("Cannot parse a null string...") 
      
      Try
         number = SByte.Parse(value, style, NumberFormatInfo.CurrentInfo)
         Console.WriteLine("SByte.Parse('{0}', {1}) = {2}", value, style, number)   
      Catch e As FormatException
         Console.WriteLine("'{0}' and {1} throw a FormatException", value, style)   
      Catch e As OverflowException
         Console.WriteLine("'{0}' is outside the range of a signed byte",
                           value)
      End Try     
   End Sub
End Module
' The example displays the following information to the console:
'       ' 123' and None throw a FormatException
'       SByte.Parse(" 123", Integer)) = 123
'       SByte.Parse("3A", AllowHexSpecifier)) = 58
'       SByte.Parse("21", Integer)) = 21
'       SByte.Parse("21", AllowHexSpecifier)) = 33
'       SByte.Parse("-22", Integer)) = -22
'       '-22' and AllowParentheses throw a FormatException
'       SByte.Parse("(45)", AllowParentheses)) = -45
'       '000,000,056' and Integer throw a FormatException
'       SByte.Parse("000,000,056", Integer, AllowThousands)) = 56

Hinweise

Der parameter style definiert die Formatvorlagenelemente (z. B. Leerzeichen oder positives oder negatives Zeichensymbol), die im parameter s zulässig sind, damit der Analysevorgang erfolgreich ausgeführt werden kann. Es muss sich um eine Kombination aus Bitkennzeichnungen aus der NumberStyles Enumeration sein.

Abhängig vom Wert von stylekann der s Parameter die folgenden Elemente enthalten:

[ws] [$] [Zeichen]Ziffern[.fractional_digits][E[Zeichen]exponential_digits][ws]

Wenn styleAllowHexSpecifierenthält, kann der parameter s die folgenden Elemente enthalten:

[ws]hexdigits[ws]

Elemente in eckigen Klammern ([ und ]) sind optional. In der folgenden Tabelle werden die einzelnen Elemente beschrieben.

Element	Beschreibung
ws	Optionaler Leerraum. Leerzeichen können am Anfang s angezeigt werden, wenn style das NumberStyles.AllowLeadingWhite Flag enthält, und es kann am Ende der s angezeigt werden, wenn style das NumberStyles.AllowTrailingWhite Flag enthält.
$	Ein kulturspezifisches Währungssymbol. Die Position in der Zeichenfolge wird durch die NumberFormatInfo.CurrencyPositivePattern Eigenschaft der aktuellen Kultur definiert. Das Währungssymbol der aktuellen Kultur kann in s angezeigt werden, wenn style das NumberStyles.AllowCurrencySymbol Flag enthält.
signieren	Ein optionales Zeichen. Das Zeichen kann am Anfang s angezeigt werden, wenn style das NumberStyles.AllowLeadingSign Flag enthält, und es kann das Ende der s angezeigt werden, wenn style das NumberStyles.AllowTrailingSign Flag enthält. Klammern können in s verwendet werden, um einen negativen Wert anzugeben, wenn style das NumberStyles.AllowParentheses Flag enthält.
Ziffern	Eine Sequenz von Ziffern von 0 bis 9.
.	Ein kulturspezifisches Dezimalkommasymbol. Das Dezimalkommasymbol der aktuellen Kultur kann in s angezeigt werden, wenn style das NumberStyles.AllowDecimalPoint Flag enthält.
fractional_digits	Mindestens ein Vorkommen der Ziffer 0-9, wenn style die NumberStyles.AllowExponent-Kennzeichnung enthält, oder mindestens ein Vorkommen der Ziffer 0, wenn dies nicht der Fall ist. Dezimalstellen können nur in s angezeigt werden, wenn style das NumberStyles.AllowDecimalPoint Flag enthält.
E	Das Zeichen "e" oder "E", das angibt, dass der Wert in exponentieller (wissenschaftlicher) Schreibweise dargestellt wird. Der s-Parameter kann eine Zahl in exponentieller Notation darstellen, wenn style das NumberStyles.AllowExponent Flag enthält.
exponential_digits	Eine Sequenz von Ziffern von 0 bis 9. Der s-Parameter kann eine Zahl in exponentieller Notation darstellen, wenn style das NumberStyles.AllowExponent Flag enthält.
hexdigits	Eine Abfolge von hexadezimalen Ziffern von 0 bis f oder 0 bis F.

Anmerkung

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

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

Nicht zusammengesetzte NumberStyles Werte	Elemente, die zusätzlich zu Ziffern in s zulässig sind
NumberStyles.None	Nur Dezimalziffern.
NumberStyles.AllowDecimalPoint	Der Dezimalkomma (.) und fractional_digits Elemente. Wenn die Formatvorlage jedoch nicht die NumberStyles.AllowExponent-Kennzeichnung enthält, darf fractional_digits nur aus einer oder mehreren 0 Ziffern bestehen; andernfalls wird ein OverflowException ausgelöst.
NumberStyles.AllowExponent	Das Zeichen "e" oder "E", das exponentielle Notation zusammen mit exponential_digitsangibt.
NumberStyles.AllowLeadingWhite	Das ws-Element am Anfang s.
NumberStyles.AllowTrailingWhite	Das ws-Element am Ende s.
NumberStyles.AllowLeadingSign	Ein positives Vorzeichen vor Ziffern.
NumberStyles.AllowTrailingSign	Ein positives Zeichen nach Ziffern.
NumberStyles.AllowParentheses	Klammern vor und nach Ziffern, um einen negativen Wert anzugeben.
NumberStyles.AllowThousands	Das Gruppentrennzeichen (,) -Element. Obwohl das Gruppentrennzeichen in sangezeigt werden kann, muss es nur einer oder mehreren Ziffern vorangestellt werden.
NumberStyles.AllowCurrencySymbol	Das Währungselement ($)

Wenn das NumberStyles.AllowHexSpecifier-Flag verwendet wird, muss s ein Hexadezimalwert sein. Gültige Hexadezimalziffern sind 0-9, a-f und A-F. Die einzigen anderen Flags, die mit ihr kombiniert werden können, sind NumberStyles.AllowLeadingWhite und NumberStyles.AllowTrailingWhite. (Die NumberStyles-Aufzählung enthält eine zusammengesetzte Zahlenformatvorlage, NumberStyles.HexNumber, die beide Leerzeichen enthält.)

Anmerkung

Wenn der parameter s die Zeichenfolgendarstellung einer Hexadezimalzahl ist, kann keine Dekoration (z. B. 0x oder &h) vorangestellt werden, die ihn als hexadezimale Zahl unterscheidet. Dies bewirkt, dass der Analysevorgang eine Ausnahme auslöst.

Wenn s eine hexadezimale Zahl darstellt, interpretiert die Parse(String, NumberStyles)-Methode das Bit mit hoher Reihenfolge des Bytes als Zeichenbit.

Der provider-Parameter ist eine IFormatProvider Implementierung, deren GetFormat-Methode ein NumberFormatInfo-Objekt zurückgibt, das kulturspezifische Informationen zum Format der sbereitstellt. Es gibt drei Möglichkeiten, den parameter provider zum Bereitstellen von benutzerdefinierten Formatierungsinformationen für den Analysevorgang zu verwenden:

• Sie können das tatsächliche NumberFormatInfo-Objekt übergeben, das Formatierungsinformationen bereitstellt. (Ihre Umsetzung von GetFormat gibt sich einfach selbst zurück.)

• Sie können ein CultureInfo-Objekt übergeben, das die Kultur angibt, deren Formatierung verwendet werden soll. Die NumberFormat-Eigenschaft stellt Formatierungsinformationen bereit.

• Sie können eine benutzerdefinierte IFormatProvider Implementierung übergeben. Die GetFormat-Methode muss das NumberFormatInfo-Objekt instanziieren und zurückgeben, das Formatierungsinformationen bereitstellt.

Wenn providernullist, wird das NumberFormatInfo Objekt für die aktuelle Kultur verwendet.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Quelle:

SByte.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Konvertiert die Spandarstellung einer Zahl, die sich in einem angegebenen Format und einem kulturspezifischen Format befindet, in sein 8-Bit-Äquivalent.

public static sbyte Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);

static member Parse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider -> sbyte

Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As SByte

Parameter

s

ReadOnlySpan<Char>

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

style

NumberStyles

Eine bitweise Kombination der Enumerationswerte, die die Formatvorlagenelemente angibt, die in svorhanden sein können. Ein typischer Wert, der angegeben werden soll, ist Integer.

provider

IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu sbereitstellt. Wenn providernullist, wird die aktuelle Threadkultur verwendet.

Gibt zurück

SByte

Ein 8-Bit-Bytewert, der der im s-Parameter angegebenen Zahl entspricht.

Implementiert

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Quelle:

SByte.cs

Analysiert eine Spanne von UTF-8 Zeichen in einen Wert.

public static sbyte Parse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);

static member Parse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider -> sbyte

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As SByte

Parameter

utf8Text

ReadOnlySpan<Byte>

Die Spanne von UTF-8 Zeichen, die analysiert werden sollen.

style

NumberStyles

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

provider

IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu utf8Textbereitstellt.

Gibt zurück

SByte

Das Ergebnis der Analyse utf8Text.

Implementiert

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parse(String, IFormatProvider)

Quelle:

SByte.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative

System.Int16.Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in dessen 8-Bit-Ganzzahläquivalent.

public:
 static System::SByte Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<System::SByte>::Parse;

public static sbyte Parse (string s, IFormatProvider? provider);

static member Parse : string * IFormatProvider -> sbyte

Public Shared Function Parse (s As String, provider As IFormatProvider) As SByte

Parameter

s

String

Eine Zeichenfolge, die eine zahl darstellt, die konvertiert werden soll. Die Zeichenfolge wird mithilfe der Integer-Formatvorlage interpretiert.

provider

IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu sbereitstellt. Wenn providernullist, wird die aktuelle Threadkultur verwendet.

Gibt zurück

SByte

Eine 8-Bit-ganzzahl mit Vorzeichen, die der in sangegebenen Zahl entspricht.

Implementiert

Parse(String, IFormatProvider)

Ausnahmen

ArgumentNullException

s ist null.

FormatException

s ist nicht im richtigen Format vorhanden.

OverflowException

s stellt eine Zahl kleiner als SByte.MinValue oder größer als SByte.MaxValuedar.

Beispiele

Im folgenden Beispiel wird ein benutzerdefiniertes NumberFormatInfo -Objekt definiert, das die Tilde (~) als negatives Zeichen definiert. Anschließend analysiert sie eine Reihe numerischer Zeichenfolgen mithilfe dieses benutzerdefinierten NumberFormatInfo Objekts sowie ein CultureInfo-Objekt, das die invariante Kultur darstellt.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      NumberFormatInfo nf = new NumberFormatInfo();
      nf.NegativeSign = "~"; 
      
      string[] values = { "-103", "+12", "~16", "  1", "~255" };
      IFormatProvider[] providers = { nf, CultureInfo.InvariantCulture };
      
      foreach (IFormatProvider provider in providers)
      {
         Console.WriteLine("Conversions using {0}:", ((object) provider).GetType().Name);
         foreach (string value in values)
         {
            try {
               Console.WriteLine("   Converted '{0}' to {1}.", 
                                 value, SByte.Parse(value, provider));
            }                     
            catch (FormatException) {
               Console.WriteLine("   Unable to parse '{0}'.", value);   
            }
            catch (OverflowException) {
               Console.WriteLine("   '{0}' is out of range of the SByte type.", value);         
            }
         }
      }      
   }
}
// The example displays the following output:
//       Conversions using NumberFormatInfo:
//          Unable to parse '-103'.
//          Converted '+12' to 12.
//          Converted '~16' to -16.
//          Converted '  1' to 1.
//          '~255' is out of range of the SByte type.
//       Conversions using CultureInfo:
//          Converted '-103' to -103.
//          Converted '+12' to 12.
//          Unable to parse '~16'.
//          Converted '  1' to 1.
//          Unable to parse '~255'.

open System
open System.Globalization

let nf = NumberFormatInfo()
nf.NegativeSign <- "~" 

let values = [| "-103"; "+12"; "~16"; "  1"; "~255" |]
let providers: IFormatProvider[] = [| nf; CultureInfo.InvariantCulture |]

for provider in providers do
    printfn $"Conversions using {(box provider).GetType().Name}:"
    for value in values do
        try
            printfn $"   Converted '{value}' to {SByte.Parse(value, provider)}."
        with
        | :? FormatException ->
            printfn $"   Unable to parse '{value}'."
        | :? OverflowException ->
            printfn $"   '{value}' is out of range of the SByte type."

// The example displays the following output:
//       Conversions using NumberFormatInfo:
//          Unable to parse '-103'.
//          Converted '+12' to 12.
//          Converted '~16' to -16.
//          Converted '  1' to 1.
//          '~255' is out of range of the SByte type.
//       Conversions using CultureInfo:
//          Converted '-103' to -103.
//          Converted '+12' to 12.
//          Unable to parse '~16'.
//          Converted '  1' to 1.
//          Unable to parse '~255'.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim nf As New NumberFormatInfo()
      nf.NegativeSign = "~" 
      
      Dim values() As String = { "-103", "+12", "~16", "  1", "~255" }
      Dim providers() As IFormatProvider = { nf, CultureInfo.InvariantCulture }
      
      For Each provider As IFormatProvider In providers
         Console.WriteLine("Conversions using {0}:", CObj(provider).GetType().Name)
         For Each value As String In values
            Try
               Console.WriteLine("   Converted '{0}' to {1}.", _
                                 value, SByte.Parse(value, provider))
            Catch e As FormatException
               Console.WriteLine("   Unable to parse '{0}'.", value)   
            Catch e As OverflowException
               Console.WriteLine("   '{0}' is out of range of the SByte type.", value)         
            End Try
         Next
      Next      
   End Sub
End Module
' The example displays '
'       Conversions using NumberFormatInfo:
'          Unable to parse '-103'.
'          Converted '+12' to 12.
'          Converted '~16' to -16.
'          Converted '  1' to 1.
'          '~255' is out of range of the SByte type.
'       Conversions using CultureInfo:
'          Converted '-103' to -103.
'          Converted '+12' to 12.
'          Unable to parse '~16'.
'          Converted '  1' to 1.
'          Unable to parse '~255'.

Hinweise

Der parameter s enthält eine Zahl des Formulars:

[ws] [Zeichen]Ziffern[ws]

Elemente in eckigen Klammern ([ und ]) sind optional. In der folgenden Tabelle werden die einzelnen Elemente beschrieben.

Element	Beschreibung
ws	Optionaler Leerraum.
signieren	Ein optionales Zeichen.
Ziffern	Eine Sequenz von Ziffern zwischen 0 und 9.

Der s-Parameter wird mithilfe der Integer-Formatvorlage interpretiert. Neben den Dezimalstellen des Bytewerts sind nur führende und nachfolgende Leerzeichen mit einem vorangestellten Zeichen zulässig. Um die Formatvorlagenelemente explizit mit den kulturspezifischen Formatierungsinformationen zu definieren, die in svorhanden sein können, verwenden Sie die Parse(String, NumberStyles, IFormatProvider)-Methode.

Der provider-Parameter ist eine IFormatProvider Implementierung, deren GetFormat-Methode ein NumberFormatInfo-Objekt zurückgibt, das kulturspezifische Informationen zum Format der sbereitstellt. Es gibt drei Möglichkeiten, den parameter provider zum Bereitstellen von benutzerdefinierten Formatierungsinformationen für den Analysevorgang zu verwenden:

• Sie können das tatsächliche NumberFormatInfo-Objekt übergeben, das Formatierungsinformationen bereitstellt. (Ihre Umsetzung von GetFormat gibt sich einfach selbst zurück.)

• Sie können ein CultureInfo-Objekt übergeben, das die Kultur angibt, deren Formatierung verwendet werden soll. Die NumberFormat-Eigenschaft stellt Formatierungsinformationen bereit.

• Sie können eine benutzerdefinierte IFormatProvider Implementierung übergeben. Die GetFormat-Methode muss das NumberFormatInfo-Objekt instanziieren und zurückgeben, das Formatierungsinformationen bereitstellt.

Wenn providernullist, wird das NumberFormatInfo Objekt für die aktuelle Kultur verwendet.

Weitere Informationen

• ToString()
• TryParse
• Analysieren numerischer Zeichenfolgen in .NET-

Parse(String)

Quelle:

SByte.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative

System.Int16.Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Zahl in die 8-Bit-ganzzahlige Entsprechung mit Vorzeichen.

public:
 static System::SByte Parse(System::String ^ s);

public static sbyte Parse (string s);

static member Parse : string -> sbyte

Public Shared Function Parse (s As String) As SByte

Parameter

s

String

Eine Zeichenfolge, die eine zahl darstellt, die konvertiert werden soll. Die Zeichenfolge wird mithilfe der Integer-Formatvorlage interpretiert.

Gibt zurück

SByte

Eine 8-Bit-ganzzahl mit Vorzeichen, die der im s Parameter enthaltenen Zahl entspricht.

Ausnahmen

ArgumentException

s ist null.

FormatException

s besteht nicht aus einem optionalen Vorzeichen gefolgt von einer Sequenz von Ziffern (Null bis neun).

OverflowException

s stellt eine Zahl kleiner als SByte.MinValue oder größer als SByte.MaxValuedar.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie ein Zeichenfolgenwert mithilfe der Parse-Methode in einen signierten Bytewert konvertiert wird. Der resultierende signierte Bytewert wird dann in der Konsole angezeigt.

// Define an array of numeric strings.
string[] values = { "-16", "  -3", "+ 12", " +12 ", "  12  ",
                    "+120", "(103)", "192", "-160" };
                           
// Parse each string and display the result.
foreach (string value in values)
{
   try {
      Console.WriteLine("Converted '{0}' to the SByte value {1}.",
                        value, SByte.Parse(value));
   }
   catch (FormatException) {
      Console.WriteLine("'{0}' cannot be parsed successfully by SByte type.",
                        value);
   }                              
   catch (OverflowException) {
      Console.WriteLine("'{0}' is out of range of the SByte type.",
                        value);
   }                                                                        
}
// The example displays the following output:
//       Converted '-16' to the SByte value -16.
//       Converted '  -3' to the SByte value -3.
//       '+ 12' cannot be parsed successfully by SByte type.
//       Converted ' +12 ' to the SByte value 12.
//       Converted '  12  ' to the SByte value 12.
//       Converted '+120' to the SByte value 120.
//       '(103)' cannot be parsed successfully by SByte type.
//       '192' is out of range of the SByte type.
//       '-160' is out of range of the SByte type.

open System

// Define an array of numeric strings.
let values = 
    [| "-16"; "  -3"; "+ 12"; " +12 "; "  12  "
       "+120"; "(103)"; "192"; "-160" |]
                            
// Parse each string and display the result.
for value in values do
    try
        printfn $"Converted '{value}' to the SByte value {SByte.Parse value}."
    with
    | :? FormatException ->
        printfn $"'{value}' cannot be parsed successfully by SByte type."
    | :? OverflowException ->
        printfn $"'{value}' is out of range of the SByte type."
        
// The example displays the following output:
//       Converted '-16' to the SByte value -16.
//       Converted '  -3' to the SByte value -3.
//       '+ 12' cannot be parsed successfully by SByte type.
//       Converted ' +12 ' to the SByte value 12.
//       Converted '  12  ' to the SByte value 12.
//       Converted '+120' to the SByte value 120.
//       '(103)' cannot be parsed successfully by SByte type.
//       '192' is out of range of the SByte type.
//       '-160' is out of range of the SByte type.

' Define an array of numeric strings.
Dim values() As String = { "-16", "  -3", "+ 12", " +12 ", "  12  ", _
                           "+120", "(103)", "192", "-160" }
                           
' Parse each string and display the result.
For Each value As String In values
   Try
      Console.WriteLine("Converted '{0}' to the SByte value {1}.", _
                        value, SByte.Parse(value))
   Catch e As FormatException
      Console.WriteLine("'{0}' cannot be parsed successfully by SByte type.", _
                        value)
   Catch e As OverflowException
      Console.WriteLine("'{0}' is out of range of the SByte type.", _
                        value)
   End Try                                                                        
Next        
' The example displays the following output:
'       Converted '-16' to the SByte value -16.
'       Converted '  -3' to the SByte value -3.
'       '+ 12' cannot be parsed successfully by SByte type.
'       Converted ' +12 ' to the SByte value 12.
'       Converted '  12  ' to the SByte value 12.
'       Converted '+120' to the SByte value 120.
'       '(103)' cannot be parsed successfully by SByte type.
'       '192' is out of range of the SByte type.
'       '-160' is out of range of the SByte type.

Hinweise

Der parameter s enthält eine Zahl des Formulars:

[ws] [Zeichen]Ziffern[ws]

Elemente in eckigen Klammern ([ und ]) sind optional. In der folgenden Tabelle werden die einzelnen Elemente beschrieben.

Element	Beschreibung
ws	Optionaler Leerraum.
signieren	Ein optionales Zeichen.
Ziffern	Eine Sequenz von Ziffern zwischen 0 und 9.

Der s-Parameter wird mithilfe der NumberStyles.Integer-Formatvorlage interpretiert. Neben den Dezimalstellen des Bytewerts sind nur führende und nachfolgende Leerzeichen mit einem führenden positiven oder negativen Vorzeichen zulässig. Verwenden Sie zum expliziten Definieren der Formatvorlagenelemente, die in svorhanden sein können, entweder die Parse(String, NumberStyles) oder die Parse(String, NumberStyles, IFormatProvider)-Methode.

Der s-Parameter wird mithilfe der Formatierungsinformationen in einer NumberFormatInfo analysiert, die für die aktuelle Systemkultur initialisiert wird. Weitere Informationen finden Sie unter NumberFormatInfo.CurrentInfo. Um eine Zeichenfolge mithilfe der Formatierungsinformationen einer anderen Kultur zu analysieren, verwenden Sie die Parse(String, NumberStyles, IFormatProvider)-Methode.

Weitere Informationen

• Analysieren numerischer Zeichenfolgen in .NET-
• Formatierungstypen in .NET-

Parse(ReadOnlySpan<Char>, IFormatProvider)

Quelle:

SByte.cs

Analysiert eine Spanne von Zeichen in einen Wert.

public:
 static System::SByte Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<System::SByte>::Parse;

public static sbyte Parse (ReadOnlySpan<char> s, IFormatProvider? provider);

static member Parse : ReadOnlySpan<char> * IFormatProvider -> sbyte

Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As SByte

Parameter

s

ReadOnlySpan<Char>

Die Spanne der zu analysierenden Zeichen.

provider

IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu sbereitstellt.

Gibt zurück

SByte

Das Ergebnis der Analyse s.

Implementiert

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Quelle:

SByte.cs

Analysiert eine Spanne von UTF-8 Zeichen in einen Wert.

public:
 static System::SByte Parse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider) = IUtf8SpanParsable<System::SByte>::Parse;

public static sbyte Parse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider);

static member Parse : ReadOnlySpan<byte> * IFormatProvider -> sbyte

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider) As SByte

Parameter

utf8Text

ReadOnlySpan<Byte>

Die Spanne von UTF-8 Zeichen, die analysiert werden sollen.

provider

IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu utf8Textbereitstellt.

Gibt zurück

SByte

Das Ergebnis der Analyse utf8Text.

Implementiert

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parse(String, NumberStyles)

Quelle:

SByte.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative

System.Int16.Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage in die 8-Bit-ganzzahlige Entsprechung mit Vorzeichen.

public:
 static System::SByte Parse(System::String ^ s, System::Globalization::NumberStyles style);

public static sbyte Parse (string s, System.Globalization.NumberStyles style);

static member Parse : string * System.Globalization.NumberStyles -> sbyte

Public Shared Function Parse (s As String, style As NumberStyles) As SByte

Parameter

s

String

Eine Zeichenfolge, die eine zahl enthält, die konvertiert werden soll. Die Zeichenfolge wird mithilfe der von styleangegebenen Formatvorlage interpretiert.

style

NumberStyles

Eine bitweise Kombination der Enumerationswerte, die die Formatvorlagenelemente angibt, die in svorhanden sein können. Ein typischer Wert, der angegeben werden soll, ist Integer.

Gibt zurück

SByte

Eine 8-Bit-ganzzahl mit Vorzeichen, die der in sangegebenen Zahl entspricht.

Ausnahmen

ArgumentNullException

s ist null.

FormatException

s ist nicht in einem Format vorhanden, das mit stylekompatibel ist.

OverflowException

s stellt eine Zahl kleiner als SByte.MinValue oder größer als SByte.MaxValuedar.

-oder-

s enthält Nicht-Null-Dezimalstellen.

ArgumentException

style ist kein NumberStyles Wert.

-oder-

style ist keine Kombination aus AllowHexSpecifier und HexNumber Werten.

Beispiele

Im folgenden Beispiel werden Zeichenfolgendarstellungen von SByte Werten mit der Parse(String, NumberStyles)-Methode analysiert. Die aktuelle Kultur für das Beispiel ist en-US.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      NumberStyles style;
      sbyte number;

      // Parse value with no styles allowed.
      string[] values1 = { " 121 ", "121", "-121" };
      style = NumberStyles.None;
      Console.WriteLine("Styles: {0}", style.ToString());
      foreach (string value in values1)
      {
         try {
            number = SByte.Parse(value, style);
            Console.WriteLine("   Converted '{0}' to {1}.", value, number);
         }   
         catch (FormatException) {
            Console.WriteLine("   Unable to parse '{0}'.", value);
         }
      }
      Console.WriteLine();
            
      // Parse value with trailing sign.
      style = NumberStyles.Integer | NumberStyles.AllowTrailingSign;
      string[] values2 = { " 103+", " 103 +", "+103", "(103)", "   +103  " };
      Console.WriteLine("Styles: {0}", style.ToString());
      foreach (string value in values2)
      {
         try {
            number = SByte.Parse(value, style);
            Console.WriteLine("   Converted '{0}' to {1}.", value, number);
         }   
         catch (FormatException) {
            Console.WriteLine("   Unable to parse '{0}'.", value);
         }      
         catch (OverflowException) {
            Console.WriteLine("   '{0}' is out of range of the SByte type.", value);         
         }
      }      
      Console.WriteLine();
   }
}
// The example displays the following output:
//       Styles: None
//          Unable to parse ' 121 '.
//          Converted '121' to 121.
//          Unable to parse '-121'.
//       
//       Styles: Integer, AllowTrailingSign
//          Converted ' 103+' to 103.
//          Converted ' 103 +' to 103.
//          Converted '+103' to 103.
//          Unable to parse '(103)'.
//          Converted '   +103  ' to 103.

open System
open System.Globalization

// Parse value with no styles allowed.
let values1 = [| " 121 "; "121"; "-121" |]
let style = NumberStyles.None
printfn $"Styles: {style}"
for value in values1 do
    try
        let number = SByte.Parse(value, style)
        printfn $"   Converted '{value}' to {number}."
    with :? FormatException ->
        printfn $"   Unable to parse '{value}'."
printfn ""
            
// Parse value with trailing sign.
let style2 = NumberStyles.Integer ||| NumberStyles.AllowTrailingSign
let values2 = [| " 103+"; " 103 +"; "+103"; "(103)"; "   +103  " |]
printfn $"Styles: {style2}"
for value in values2 do
    try
        let number = SByte.Parse(value, style2)
        printfn $"   Converted '{value}' to {number}."
    with 
    | :? FormatException ->
        printfn $"   Unable to parse '{value}'."
    | :? OverflowException ->
        printfn $"   '{value}' is out of range of the SByte type."         
printfn ""
// The example displays the following output:
//       Styles: None
//          Unable to parse ' 121 '.
//          Converted '121' to 121.
//          Unable to parse '-121'.
//       
//       Styles: Integer, AllowTrailingSign
//          Converted ' 103+' to 103.
//          Converted ' 103 +' to 103.
//          Converted '+103' to 103.
//          Unable to parse '(103)'.
//          Converted '   +103  ' to 103.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim style As NumberStyles
      Dim number As SByte

      ' Parse value with no styles allowed.
      Dim values1() As String = { " 121 ", "121", "-121" }
      style = NumberStyles.None
      Console.WriteLine("Styles: {0}", style.ToString())
      For Each value As String In values1
         Try
            number = SByte.Parse(value, style)
            Console.WriteLine("   Converted '{0}' to {1}.", value, number)
         Catch e As FormatException
            Console.WriteLine("   Unable to parse '{0}'.", value)   
         End Try
      Next
      Console.WriteLine()
            
      ' Parse value with trailing sign.
      style = NumberStyles.Integer Or NumberStyles.AllowTrailingSign
      Dim values2() As String = { " 103+", " 103 +", "+103", "(103)", "   +103  " }
      Console.WriteLine("Styles: {0}", style.ToString())
      For Each value As String In values2
         Try
            number = SByte.Parse(value, style)
            Console.WriteLine("   Converted '{0}' to {1}.", value, number)
         Catch e As FormatException
            Console.WriteLine("   Unable to parse '{0}'.", value)   
         Catch e As OverflowException
            Console.WriteLine("   '{0}' is out of range of the SByte type.", value)         
         End Try
      Next      
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'       Styles: None
'          Unable to parse ' 121 '.
'          Converted '121' to 121.
'          Unable to parse '-121'.
'       
'       Styles: Integer, AllowTrailingSign
'          Converted ' 103+' to 103.
'          Converted ' 103 +' to 103.
'          Converted '+103' to 103.
'          Unable to parse '(103)'.
'          Converted '   +103  ' to 103.

Hinweise

Der parameter style definiert die Formatvorlagenelemente (z. B. Leerzeichen oder positives oder negatives Zeichensymbol), die im parameter s zulässig sind, damit der Analysevorgang erfolgreich ausgeführt werden kann. Es muss sich um eine Kombination aus Bitkennzeichnungen aus der NumberStyles Enumeration sein.

Abhängig vom Wert von stylekann der s Parameter die folgenden Elemente enthalten:

[ws] [$] [Zeichen]Ziffern[.fractional_digits][E[Zeichen]exponential_digits][ws]

Wenn styleNumberStyles.AllowHexSpecifierenthält, kann der parameter s die folgenden Elemente enthalten:

[ws]hexdigits[ws]

Elemente in eckigen Klammern ([ und ]) sind optional. In der folgenden Tabelle werden die einzelnen Elemente beschrieben.

Element	Beschreibung
ws	Optionaler Leerraum. Leerzeichen können am Anfang s angezeigt werden, wenn style die NumberStyles.AllowLeadingWhite-Kennzeichnung enthält, und sie kann am Ende s angezeigt werden, wenn die Formatvorlage das NumberStyles.AllowTrailingWhite Flag enthält.
$	Ein kulturspezifisches Währungssymbol. Die Position in der Zeichenfolge wird durch die NumberFormatInfo.CurrencyPositivePattern Eigenschaft der aktuellen Kultur definiert. Das Währungssymbol der aktuellen Kultur kann in s angezeigt werden, wenn style das NumberStyles.AllowCurrencySymbol Flag enthält.
signieren	Ein optionales Zeichen. Das Zeichen kann am Anfang der s angezeigt werden, wenn style das NumberStyles.AllowLeadingSign Flag enthält, und es kann am Ende s angezeigt werden, wenn style das NumberStyles.AllowTrailingSign Flag enthält. Klammern können in s verwendet werden, um einen negativen Wert anzugeben, wenn style das NumberStyles.AllowParentheses Flag enthält.
Ziffern	Eine Sequenz von Ziffern von 0 bis 9.
.	Ein kulturspezifisches Dezimalkommasymbol. Das Dezimalkommasymbol der aktuellen Kultur kann in s angezeigt werden, wenn style das NumberStyles.AllowDecimalPoint Flag enthält.
fractional_digits	Mindestens ein Vorkommen der Ziffer 0-9, wenn style die NumberStyles.AllowExponent-Kennzeichnung enthält, oder mindestens ein Vorkommen der Ziffer 0, wenn dies nicht der Fall ist. Dezimalstellen können nur in s angezeigt werden, wenn style das NumberStyles.AllowDecimalPoint Flag enthält.
E	Das Zeichen "e" oder "E", das angibt, dass der Wert in exponentieller (wissenschaftlicher) Schreibweise dargestellt wird. Der s-Parameter kann eine Zahl in exponentieller Notation darstellen, wenn style das NumberStyles.AllowExponent Flag enthält.
exponential_digits	Mindestens ein Vorkommen der Ziffer 0-9. Der s-Parameter kann eine Zahl in exponentieller Notation darstellen, wenn style das NumberStyles.AllowExponent Flag enthält.
hexdigits	Eine Abfolge von hexadezimalen Ziffern von 0 bis f oder 0 bis F.

Anmerkung

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

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

Nicht zusammengesetzte NumberStyles-Werte	Elemente, die in zusätzlich zu Ziffern zulässig sind
NumberStyles.None	Nur Dezimalziffern.
NumberStyles.AllowDecimalPoint	Der Dezimalkomma (.) und fractional_digits Elemente. Wenn style jedoch nicht die NumberStyles.AllowExponent Kennzeichnung enthält, darf fractional_digits nur aus einer oder mehreren 0 Ziffern bestehen; andernfalls wird ein OverflowException ausgelöst.
NumberStyles.AllowExponent	Das Zeichen "e" oder "E", das exponentielle Notation zusammen mit exponential_digitsangibt.
NumberStyles.AllowLeadingWhite	Das ws-Element am Anfang s.
NumberStyles.AllowTrailingWhite	Das ws-Element am Ende s.
NumberStyles.AllowLeadingSign	Ein positives Vorzeichen vor Ziffern.
NumberStyles.AllowTrailingSign	Ein positives Zeichen nach Ziffern.
NumberStyles.AllowParentheses	Das Zeichen Element in Form von Klammern, die den numerischen Wert einschließen.
NumberStyles.AllowThousands	Das Gruppentrennzeichen (,) -Element. Obwohl das Gruppentrennzeichen in sangezeigt werden kann, muss es nur einer oder mehreren Ziffern vorangestellt werden.
NumberStyles.AllowCurrencySymbol	Das Währungselement ($)

Wenn das NumberStyles.AllowHexSpecifier-Flag verwendet wird, muss s ein Hexadezimalwert sein. Gültige Hexadezimalziffern sind 0-9, a-f und A-F. Ein Präfix wie "0x" wird nicht unterstützt und bewirkt, dass der Analysevorgang fehlschlägt. Die einzigen anderen Kennzeichen, die in style kombiniert werden können, sind NumberStyles.AllowLeadingWhite und NumberStyles.AllowTrailingWhite. (Die NumberStyles-Aufzählung enthält eine zusammengesetzte Zahlenformatvorlage, NumberStyles.HexNumber, die beide Leerzeichen enthält.)

Anmerkung

Wenn der parameter s die Zeichenfolgendarstellung einer Hexadezimalzahl ist, kann keine Dekoration (z. B. 0x oder &h) vorangestellt werden, die ihn als hexadezimale Zahl unterscheidet. Dies bewirkt, dass der Analysevorgang eine Ausnahme auslöst.

Wenn s eine hexadezimale Zahl darstellt, interpretiert die Parse(String, NumberStyles)-Methode das Bit mit hoher Reihenfolge des Bytes als Zeichenbit.

Der s-Parameter wird mithilfe der Formatierungsinformationen in einem NumberFormatInfo-Objekt analysiert, das für die aktuelle Systemkultur initialisiert wird. Um die Formatierungsinformationen einer anderen Kultur zu verwenden, rufen Sie die Parse(String, NumberStyles, IFormatProvider) Überladung auf.

Weitere Informationen

• ToString()
• TryParse
• Analysieren numerischer Zeichenfolgen in .NET-
• Formatierungstypen in .NET-