SByte.Parse Methode

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende 8-Bit-Ganzzahl mit Vorzeichen.

Überlädt

Parse(String, NumberStyles, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturabhängigen Format in die entsprechende ganze 8-Bit-Zahl mit Vorzeichen.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konvertiert die Spannendarstellung einer Zahl in einem angegebenen Stil und einem kulturabhängigen Format in die entsprechende 8-Bit-Zahl mit Vorzeichen.
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 die entsprechende 8-Bit-Ganzzahl mit Vorzeichen.
Parse(String)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende 8-Bit-Ganzzahl 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 einem angegebenen Stil in die entsprechende 8-Bit-Ganzzahl mit Vorzeichen.

Parse(String, NumberStyles, IFormatProvider)

Source:

SByte.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative

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

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturabhängigen Format in die entsprechende ganze 8-Bit-Zahl mit Vorzeichen.

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 unter Verwendung des durch style angegebenen Formats interpretiert.

style

NumberStyles

Eine bitweise Kombination von Enumerationswerten, die die Stilelemente angibt, 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.

Gibt zurück

SByte

Eine ganze 8-Bit-Zahl mit Vorzeichen, die 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 weist kein mit style kompatibles Format auf.

OverflowException

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

- oder -

s enthält Dezimalstellen ungleich 0 (null).

Beispiele

Das folgende Beispiel veranschaulicht die Verwendung der Parse(String, NumberStyles, IFormatProvider) -Methode zum Konvertieren verschiedener Zeichenfolgendarstellungen von Zahlen in ganzzahlige Werte mit Vorzeichen.

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 style Parameter definiert die Stilelemente (z. B. Leerzeichen oder das positive oder negative Zeichensymbol), die im s Parameter zulässig sind, damit der Analysevorgang erfolgreich ist. 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] [$][Zeichen]Ziffern[.fractional_digits][E[sign]exponential_digits][ws]

Wenn style enthält AllowHexSpecifier, kann der s Parameter die folgenden Elemente enthalten:

[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, und es kann am Ende von s angezeigt werden, wenn style das NumberStyles.AllowTrailingWhite Flag enthält.
$	Ein kulturspezifisches Währungssymbol. Ihre 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.
sign	Ein optionales Zeichen. Das Zeichen kann am Anfang von s angezeigt werden, wenn style das NumberStyles.AllowLeadingSign Flag enthält, und es kann das Ende von 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 enthalten ist.
Zahlen	Eine Sequenz von Ziffern von 0 bis 9.
.	Ein kulturspezifisches Dezimaltrennzeichen. Das Dezimalzeichensymbol 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 das NumberStyles.AllowExponent Flag enthalten ist, oder mindestens ein Vorkommen der Ziffer 0, wenn dies nicht der Fall ist. 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 (wissenschaftlicher) Notation dargestellt wird. Der s Parameter kann eine Zahl in exponentieller Notation darstellen, wenn style das NumberStyles.AllowExponent Flag enthalten ist.
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 enthalten ist.
hexdigits	Eine Sequenz von Hexadezimalstellen von 0 bis f oder 0 bis F.

Hinweis

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

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

Nicht zusammengesetzte NumberStyles Werte	Zusätzlich zu Ziffern zulässige s Elemente
NumberStyles.None	Nur Dezimalstellen.
NumberStyles.AllowDecimalPoint	Das Dezimaltrennzeichen (.) und fractional_digits Elemente. Wenn die NumberStyles.AllowExponent Formatvorlage jedoch das Flag nicht enthält, muss fractional_digits nur aus einer oder mehreren 0 Ziffern bestehen. Andernfalls wird eine OverflowException ausgelöst.
NumberStyles.AllowExponent	Das Zeichen "e" oder "E", das die exponentielle Notation angibt, zusammen mit exponential_digits.
NumberStyles.AllowLeadingWhite	Das ws-Element am Anfang von s.
NumberStyles.AllowTrailingWhite	Das ws-Element am Ende von 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 ihm nur eine oder mehrere 0 Ziffern vorangestellt werden.
NumberStyles.AllowCurrencySymbol	Das Währungselement ($).

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

Hinweis

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

Wenn s eine hexadezimale Zahl darstellt, interpretiert die Parse(String, NumberStyles) -Methode das Hochreihenfolge-Bit des Byte als Vorzeichenbit.

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

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

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

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

Wenn provider ist null, wird das NumberFormatInfo Objekt für die aktuelle Kultur verwendet.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Source:

SByte.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Konvertiert die Spannendarstellung einer Zahl in einem angegebenen Stil und einem kulturabhängigen Format in die entsprechende 8-Bit-Zahl mit Vorzeichen.

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>

Die Spanne mit den Zeichen, die die zu konvertierende Zahl darstellen. Die Spanne wird unter Verwendung des durch style angegebenen Stils interpretiert.

style

NumberStyles

Eine bitweise Kombination von Enumerationswerten, die die Stilelemente angibt, 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.

Gibt zurück

SByte

Eine ganze 8-Bit-Zahl mit Vorzeichen, die der im s-Parameter angegebenen Zahl entspricht.

Implementiert

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Source:

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 der zu analysierenden UTF-8-Zeichen.

style

NumberStyles

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

provider

IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu utf8Text bereitstellt.

Gibt zurück

SByte

Das Ergebnis der Analyse utf8Text.

Implementiert

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parse(String, IFormatProvider)

Source:

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 die entsprechende 8-Bit-Ganzzahl mit Vorzeichen.

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 zu konvertierende Zahl darstellt. Die Zeichenfolge wird unter Verwendung des Integer-Formats interpretiert.

provider

IFormatProvider

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

Gibt zurück

SByte

Eine ganze 8-Bit-Zahl mit Vorzeichen, die der Zahl in s entspricht.

Implementiert

Parse(String, IFormatProvider)

Ausnahmen

ArgumentNullException

s ist null.

FormatException

s weist nicht das richtige Format auf.

OverflowException

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

Beispiele

Im folgenden Beispiel wird ein benutzerdefiniertes NumberFormatInfo Objekt definiert, das die Tilde (~) als negatives Zeichen definiert. Anschließend analysiert es eine Reihe von numerischen Zeichenfolgen mit diesem benutzerdefinierten NumberFormatInfo Objekt 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 s Parameter enthält eine Nummer des Formulars:

[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 Zeichen.
Zahlen	Eine Sequenz von Ziffern zwischen 0 und 9.

Der s Parameter wird mithilfe des Stils Integer interpretiert. Zusätzlich zu den Dezimalstellen des Bytewerts sind nur führende und nachfolgende Leerzeichen mit einem führenden Zeichen zulässig. Verwenden Sie die -Methode, um die Stilelemente explizit mit den kulturspezifischen Formatierungsinformationen zu definieren, die Parse(String, NumberStyles, IFormatProvider) in svorhanden sein können.

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

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

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

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

Wenn provider ist null, wird das NumberFormatInfo Objekt für die aktuelle Kultur verwendet.

Weitere Informationen

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

Parse(String)

Source:

SByte.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative

System.Int16.Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende 8-Bit-Ganzzahl 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 zu konvertierende Zahl darstellt. Die Zeichenfolge wird unter Verwendung des Integer-Formats interpretiert.

Gibt zurück

SByte

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

Ausnahmen

ArgumentException

s ist null.

FormatException

s besteht nicht aus einem optionalen Vorzeichen und einer Folge von Ziffern (0 bis 9).

OverflowException

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

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie ein Zeichenfolgenwert mithilfe der Parse -Methode in einen signierten Bytewert konvertiert wird. Der resultierende 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 s Parameter enthält eine Nummer des Formulars:

[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 Zeichen.
Zahlen	Eine Sequenz von Ziffern zwischen 0 und 9.

Der s Parameter wird mithilfe des Stils NumberStyles.Integer interpretiert. Zusätzlich zu den Dezimalstellen des Bytewerts sind nur führende und nachfolgende Leerzeichen mit einem positiven oder negativen Vorzeichen zulässig. Verwenden Sie entweder die -Methode oder, um die Formatvorlagenelemente explizit zu definieren, die Parse(String, NumberStyles)Parse(String, NumberStyles, IFormatProvider) in svorhanden sein können.

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. Verwenden Sie die Parse(String, NumberStyles, IFormatProvider) -Methode, um eine Zeichenfolge mithilfe der Formatierungsinformationen einer anderen Kultur zu analysieren.

Weitere Informationen

• Analysieren numerischer Zeichenfolgen in .NET
• Formatieren von Typen in .NET

Parse(ReadOnlySpan<Char>, IFormatProvider)

Source:

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 s bereitstellt.

Gibt zurück

SByte

Das Ergebnis der Analyse s.

Implementiert

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Source:

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 der zu analysierenden UTF-8-Zeichen.

provider

IFormatProvider

Ein Objekt, das kulturspezifische Formatierungsinformationen zu utf8Text bereitstellt.

Gibt zurück

SByte

Das Ergebnis der Analyse utf8Text.

Implementiert

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parse(String, NumberStyles)

Source:

SByte.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative

System.Int16.Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die entsprechende 8-Bit-Ganzzahl 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 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 angibt, die in s vorhanden sein können. Ein häufig angegebener Wert ist Integer.

Gibt zurück

SByte

Eine ganze 8-Bit-Zahl mit Vorzeichen, die der Zahl in s entspricht.

Ausnahmen

ArgumentNullException

s ist null.

FormatException

s weist kein mit style kompatibles Format auf.

OverflowException

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

- oder -

s enthält Dezimalstellen ungleich 0 (null).

ArgumentException

style ist kein NumberStyles-Wert.

- oder -

style ist keine Kombination von 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 style -Parameter definiert die Stilelemente (z. B. Leerzeichen oder positives oder negatives Zeichensymbol), 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] [$][Zeichen]Ziffern[.fractional_digits][E[sign]exponential_digits][ws]

Wenn style enthält NumberStyles.AllowHexSpecifier, kann der s Parameter die folgenden Elemente enthalten:

[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, und es kann am Ende s angezeigt werden, wenn die Formatvorlage das NumberStyles.AllowTrailingWhite Flag enthält.
$	Ein kulturspezifisches Währungssymbol. Seine 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 enthalten ist.
sign	Ein optionales Zeichen. Das Zeichen kann am Anfang von s angezeigt werden, wenn style das NumberStyles.AllowLeadingSign Flag enthält, und es kann am Ende s von 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 enthalten ist.
Zahlen	Eine Sequenz von Ziffern von 0 bis 9.
.	Ein kulturspezifisches Dezimalzeichensymbol. Das Dezimalstellensymbol der aktuellen Kultur kann in s angezeigt werden, wenn style das NumberStyles.AllowDecimalPoint Flag enthalten ist.
fractional_digits	Ein oder mehrere Vorkommen der Ziffer 0-9, wenn style das NumberStyles.AllowExponent Flag enthalten ist, oder mindestens ein Vorkommen der Ziffer 0, wenn dies nicht der Fall ist. 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 (wissenschaftlicher) Notation dargestellt wird. Der s Parameter kann eine Zahl in exponentieller Notation darstellen, wenn style das NumberStyles.AllowExponent Flag enthalten ist.
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 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 möglicherweise vorhanden sind, aber nicht erforderlich sind, um in der Eingabezeichenfolge vorhanden zu sein. 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	Das Dezimalzeichen (.) und fractional_digits Elemente. Wenn style das NumberStyles.AllowExponent Flag jedoch nicht enthalten ist, 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 die exponentielle Notation angibt, zusammen mit exponential_digits.
NumberStyles.AllowLeadingWhite	Das ws-Element am Anfang von s.
NumberStyles.AllowTrailingWhite	Das ws-Element am Ende von s.
NumberStyles.AllowLeadingSign	Ein positives Zeichen vor Ziffern.
NumberStyles.AllowTrailingSign	Ein positives Zeichen nach Ziffern.
NumberStyles.AllowParentheses	Das Zeichenelement in Form von Klammern, die den numerischen Wert einschließen.
NumberStyles.AllowThousands	Das Gruppentrennzeichen (,)-Element. Obwohl das Gruppentrennzeichen in sangezeigt werden kann, muss ihm nur eine oder mehrere 0 Ziffern vorangestellt sein.
NumberStyles.AllowCurrencySymbol	Das Währungselement ($).

Wenn das NumberStyles.AllowHexSpecifier Flag verwendet wird, s muss es sich um einen Hexadezimalwert handelt. Gültige Hexadezimalstellen sind 0-9, a-f und A-F. Ein Präfix wie "0x" wird nicht unterstützt und führt dazu, dass der Analysevorgang fehlschlägt. Die einzigen anderen Flags, die in style kombiniert werden können, sind NumberStyles.AllowLeadingWhite und NumberStyles.AllowTrailingWhite. (Die NumberStyles Enumeration enthält eine zusammengesetzte Zahlenart, NumberStyles.HexNumber, die beide Leerzeichenflags enthält.)

Hinweis

Wenn der s Parameter die Zeichenfolgendarstellung einer hexadezimalen Zahl ist, kann ihm keine Dekoration (z 0x . B. oder &h) vorangestellt werden, die ihn als hexadezimale Zahl unterscheidet. Dadurch löst der Analysevorgang eine Ausnahme aus.

Wenn s eine hexadezimale Zahl darstellt, interpretiert die Parse(String, NumberStyles) Methode das hochgeordnete Bit des Byte als Zeichenbit.

Der s Parameter wird analysiert, indem die Formatierungsinformationen in einem NumberFormatInfo Objekt verwendet werden, 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
• Formatieren von Typen in .NET