SByte.Parse Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
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)
- Quelle:
- SByte.cs
- Quelle:
- SByte.cs
- Quelle:
- 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);
public:
static System::SByte Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<System::SByte>::Parse;
[System.CLSCompliant(false)]
public static sbyte Parse (string s, System.Globalization.NumberStyles style, IFormatProvider provider);
public static sbyte Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);
[System.CLSCompliant(false)]
public static sbyte Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);
[<System.CLSCompliant(false)>]
static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> sbyte
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
Eine ganze 8-Bit-Zahl mit Vorzeichen, die der im s
-Parameter angegebenen Zahl entspricht.
Implementiert
- Attribute
Ausnahmen
style
ist kein NumberStyles-Wert.
- oder -
style
ist keine Kombination aus AllowHexSpecifier und HexNumber.
s
ist null
.
s
weist kein mit style
kompatibles Format auf.
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 style
kann 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 s
vorhanden 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 s angezeigt 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 s
bereitstellt. 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.
Gilt für:
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)
- Quelle:
- SByte.cs
- Quelle:
- SByte.cs
- Quelle:
- 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);
[System.CLSCompliant(false)]
public static sbyte Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider provider = default);
[System.CLSCompliant(false)]
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
[<System.CLSCompliant(false)>]
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
Eine ganze 8-Bit-Zahl mit Vorzeichen, die der im s
-Parameter angegebenen Zahl entspricht.
Implementiert
- Attribute
Gilt für:
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)
- Quelle:
- SByte.cs
- 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 der zu analysierenden UTF-8-Zeichen.
- style
- NumberStyles
Eine bitweise Kombination von Zahlenformaten, die in utf8Text
vorhanden sein können.
- provider
- IFormatProvider
Ein Objekt, das kulturspezifische Formatierungsinformationen zu utf8Text
bereitstellt.
Gibt zurück
Das Ergebnis der Analyse utf8Text
.
Implementiert
Gilt für:
Parse(String, IFormatProvider)
- Quelle:
- SByte.cs
- Quelle:
- SByte.cs
- Quelle:
- SByte.cs
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);
public:
static System::SByte Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<System::SByte>::Parse;
[System.CLSCompliant(false)]
public static sbyte Parse (string s, IFormatProvider provider);
public static sbyte Parse (string s, IFormatProvider? provider);
[System.CLSCompliant(false)]
public static sbyte Parse (string s, IFormatProvider? provider);
[<System.CLSCompliant(false)>]
static member Parse : string * IFormatProvider -> sbyte
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
Eine ganze 8-Bit-Zahl mit Vorzeichen, die der Zahl in s
entspricht.
Implementiert
- Attribute
Ausnahmen
s
ist null
.
s
weist nicht das richtige Format auf.
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 s
vorhanden sein können.
Der provider
Parameter ist eine IFormatProvider Implementierung, deren GetFormat Methode ein NumberFormatInfo -Objekt zurückgibt, das kulturspezifische Informationen zum Format von s
bereitstellt. 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
Gilt für:
Parse(String)
- Quelle:
- SByte.cs
- Quelle:
- SByte.cs
- Quelle:
- SByte.cs
Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende 8-Bit-Ganzzahl mit Vorzeichen.
public:
static System::SByte Parse(System::String ^ s);
[System.CLSCompliant(false)]
public static sbyte Parse (string s);
public static sbyte Parse (string s);
[<System.CLSCompliant(false)>]
static member Parse : string -> sbyte
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
Eine ganze 8-Bit-Zahl mit Vorzeichen, die der Zahl im s
-Parameter entspricht.
- Attribute
Ausnahmen
s
ist null
.
s
besteht nicht aus einem optionalen Vorzeichen und einer Folge von Ziffern (0 bis 9).
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 s
vorhanden 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
Gilt für:
Parse(ReadOnlySpan<Char>, IFormatProvider)
- Quelle:
- SByte.cs
- Quelle:
- SByte.cs
- 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 s
bereitstellt.
Gibt zurück
Das Ergebnis der Analyse s
.
Implementiert
Gilt für:
Parse(ReadOnlySpan<Byte>, IFormatProvider)
- Quelle:
- SByte.cs
- 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 der zu analysierenden UTF-8-Zeichen.
- provider
- IFormatProvider
Ein Objekt, das kulturspezifische Formatierungsinformationen zu utf8Text
bereitstellt.
Gibt zurück
Das Ergebnis der Analyse utf8Text
.
Implementiert
Gilt für:
Parse(String, NumberStyles)
- Quelle:
- SByte.cs
- Quelle:
- SByte.cs
- Quelle:
- SByte.cs
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);
[System.CLSCompliant(false)]
public static sbyte Parse (string s, System.Globalization.NumberStyles style);
public static sbyte Parse (string s, System.Globalization.NumberStyles style);
[<System.CLSCompliant(false)>]
static member Parse : string * System.Globalization.NumberStyles -> sbyte
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
Eine ganze 8-Bit-Zahl mit Vorzeichen, die der Zahl in s
entspricht.
- Attribute
Ausnahmen
s
ist null
.
s
weist kein mit style
kompatibles Format auf.
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).
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 style
kann 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 s
vorhanden 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 s angezeigt 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
Gilt für:
Feedback
https://aka.ms/ContentUserFeedback.
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unterFeedback senden und anzeigen für