SByte.Parse Metoda
Definice
Důležité
Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.
Převádí řetězcové vyjádření čísla na jeho ekvivalent v podobě 8bitového celého čísla se znaménkem.
Přetížení
Parse(String, NumberStyles, IFormatProvider) |
Převede řetězcovou reprezentaci čísla, které je v zadaném stylu a formátu specifickém pro jazykovou verzi, na jeho 8bitový ekvivalent se znaky. |
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) |
Převede reprezentaci rozsahu čísla, které je v zadaném stylu a formátu specifickém pro jazykovou verzi, na jeho 8bitový ekvivalent se signoumi. |
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider) |
Parsuje rozsah znaků UTF-8 na hodnotu. |
Parse(String, IFormatProvider) |
Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na jeho 8bitový celočíselný ekvivalent se znaky. |
Parse(String) |
Převádí řetězcové vyjádření čísla na jeho ekvivalent v podobě 8bitového celého čísla se znaménkem. |
Parse(ReadOnlySpan<Char>, IFormatProvider) |
Parsuje rozsah znaků na hodnotu. |
Parse(ReadOnlySpan<Byte>, IFormatProvider) |
Parsuje rozsah znaků UTF-8 na hodnotu. |
Parse(String, NumberStyles) |
Převede řetězcovou reprezentaci čísla v zadaném stylu na jeho 8bitový celočíselný ekvivalent se znaky. |
Parse(String, NumberStyles, IFormatProvider)
- Zdroj:
- SByte.cs
- Zdroj:
- SByte.cs
- Zdroj:
- SByte.cs
Důležité
Toto rozhraní API neodpovídá specifikaci CLS.
- Alternativa odpovídající specifikaci CLS
- System.Int16.Parse(String, NumberStyles, IFormatProvider)
Převede řetězcovou reprezentaci čísla, které je v zadaném stylu a formátu specifickém pro jazykovou verzi, na jeho 8bitový podepsaný ekvivalent.
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
Parametry
- s
- String
Řetězec obsahující číslo k převedení. Řetězec se interpretuje pomocí stylu určeného nástrojem style
.
- style
- NumberStyles
Bitové kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v s
. Typická hodnota, která se má zadat, je Integer.
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi .s
Pokud provider
je null
, použije se aktuální jazyková verze vlákna.
Návraty
Hodnota 8bitového podepsaného bajtů, která odpovídá číslu zadanému v parametru s
.
Implementuje
- Atributy
Výjimky
s
je null
.
s
není ve formátu, který je kompatibilní s style
.
s
představuje číslo, které je menší než SByte.MinValue nebo větší než SByte.MaxValue.
-nebo-
s
obsahuje nenulové desetinné číslice.
Příklady
Následující příklad ukazuje použití metody k převodu Parse(String, NumberStyles, IFormatProvider) různých řetězcových reprezentací čísel na celočíselné hodnoty se znaky.
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
Poznámky
Parametr style
definuje prvky stylu (například prázdné znaky nebo symbol kladného nebo záporného znaménka), které jsou v parametru s
povoleny, aby operace parsování byla úspěšná. Musí se jednat o kombinaci bitových příznaků z výčtu NumberStyles .
V závislosti na hodnotě style
s
může parametr obsahovat následující prvky:
[ws] [$][sign]digits[.fractional_digits][E[sign]exponential_digits][ws]
Pokud style
obsahuje AllowHexSpecifier, s
může parametr obsahovat následující prvky:
[ws] hexdigits[ws]
Prvky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.
Element | Popis |
---|---|
Ws | Volitelné prázdné místo. Prázdné místo se může zobrazit na začátku, s pokud style obsahuje NumberStyles.AllowLeadingWhite příznak, a může se zobrazit na konci, s pokud style obsahuje NumberStyles.AllowTrailingWhite příznak. |
$ | Symbol měny pro konkrétní jazykovou verzi. Jeho pozice v řetězci je definována NumberFormatInfo.CurrencyPositivePattern vlastností aktuální jazykové verze. Symbol měny aktuální jazykové verze se může zobrazit v s , pokud style obsahuje NumberStyles.AllowCurrencySymbol příznak. |
sign | Nepovinný znak. Znaménko se může zobrazit na začátku, s pokud příznak obsahujeNumberStyles.AllowLeadingSign, a může se zobrazit na koncis , pokud style příznak obsahuje NumberStyles.AllowTrailingSignstyle . Závorky lze v s použít k označení záporné hodnoty, pokud style obsahuje NumberStyles.AllowParentheses příznak. |
Číslic | Řada číslic od 0 do 9. |
. | Symbol desetinné čárky specifický pro jazykovou verzi. Symbol desetinné čárky aktuální jazykové verze se může zobrazit v s , pokud style obsahuje NumberStyles.AllowDecimalPoint příznak. |
Fractional_digits | Jeden nebo více výskytů číslice 0-9, pokud style obsahuje NumberStyles.AllowExponent příznak, nebo jeden nebo více výskytů číslice 0, pokud není. Desetinné číslice se můžou zobrazit pouze v s případě, že style obsahuje NumberStyles.AllowDecimalPoint příznak. |
E | Znak "e" nebo "E", který určuje, že hodnota je reprezentován v exponenciální (vědecké) notaci. Parametr s může představovat číslo v exponenciálním zápisuNumberStyles.AllowExponent, pokud style obsahuje příznak. |
exponential_digits | Řada číslic od 0 do 9. Parametr s může představovat číslo v exponenciálním zápisuNumberStyles.AllowExponent, pokud style obsahuje příznak. |
šestihranné | Posloupnost šestnáctkových číslic od 0 do f nebo id 0 do F. |
Poznámka
Operace analýzy ignoruje všechny ukončující ZNAKY NUL (U+0000) bez s
ohledu na hodnotu argumentu style
.
Řetězec pouze s desetinnými číslicemi (který odpovídá NumberStyles.None stylu) se vždy úspěšně parsuje. Většina zbývajících NumberStyles členů řídí prvky, které mohou být přítomny, ale nejsou nutné, aby byly přítomny, v tomto vstupním řetězci. Následující tabulka uvádí, jak jednotlivé NumberStyles členy ovlivňují prvky, které mohou být přítomny v nástroji s
.
Neseseparované NumberStyles hodnoty |
Prvky povolené s kromě číslic |
---|---|
NumberStyles.None | Pouze desítkové číslice. |
NumberStyles.AllowDecimalPoint | Desetinná čárka (.) a fractional_digits elementy. Pokud však styl příznak neobsahuje NumberStyles.AllowExponent , musí fractional_digits obsahovat pouze jednu nebo více číslic. V opačném případě OverflowException je vyvolán znak . |
NumberStyles.AllowExponent | Znak "e" nebo "E", který označuje exponenciální zápis spolu s exponential_digits. |
NumberStyles.AllowLeadingWhite | Element ws na začátku souboru s . |
NumberStyles.AllowTrailingWhite | Element ws na konci souboru s . |
NumberStyles.AllowLeadingSign | Kladné znaménko před číslicemi. |
NumberStyles.AllowTrailingSign | Kladné znaménko za číslicemi |
NumberStyles.AllowParentheses | Závorky před číslicemi a za číslicemi označují zápornou hodnotu. |
NumberStyles.AllowThousands | Element oddělovače skupin (,). I když se oddělovač skupin může zobrazit v s , musí předcházet pouze jedna nebo více číslic 0. |
NumberStyles.AllowCurrencySymbol | Element currency ($). |
Pokud se NumberStyles.AllowHexSpecifier použije příznak, s
musí být šestnáctková hodnota. Platné šestnáctkové číslice jsou 0-9, a-f a A-F. Jedinými dalšími příznaky, které je možné s ním kombinovat, jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles obsahuje složený styl čísla , NumberStyles.HexNumberkterý zahrnuje oba příznaky prázdných znaků.)
Poznámka
s
Pokud je parametr řetězcovou reprezentací šestnáctkového čísla, nemůže předcházet žádná dekorace (například 0x
nebo&h
), která ho odlišuje jako šestnáctkové číslo. To způsobí, že operace analýzy vyvolá výjimku.
Pokud s
představuje šestnáctkové číslo, Parse(String, NumberStyles) metoda interpretuje bit s vysokým pořadím bajtu jako znaménkový bit.
Parametr provider
je IFormatProvider implementace, jejíž GetFormat metoda vrací NumberFormatInfo objekt, který poskytuje informace specifické pro jazykovou verzi s
formátu . Existují tři způsoby použití parametru provider
k poskytnutí informací o vlastním formátování do operace parsování:
Můžete předat skutečný NumberFormatInfo objekt, který poskytuje informace o formátování. (Jeho implementace jednoduše GetFormat vrátí sama sebe.)
Můžete předat CultureInfo objekt, který určuje jazykovou verzi, jejíž formátování se má použít. Jeho NumberFormat vlastnost poskytuje informace o formátování.
Můžete předat vlastní IFormatProvider implementaci. Jeho GetFormat metoda musí vytvořit instanci a vrátit NumberFormatInfo objekt, který poskytuje informace o formátování.
Pokud provider
je null
, použije se NumberFormatInfo objekt pro aktuální jazykovou verzi.
Platí pro
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)
- Zdroj:
- SByte.cs
- Zdroj:
- SByte.cs
- Zdroj:
- SByte.cs
Důležité
Toto rozhraní API neodpovídá specifikaci CLS.
Převede reprezentaci rozsahu čísla, které je v zadaném stylu a formátu specifickém pro jazykovou verzi, na jeho 8bitový ekvivalent se sadou se sadou.
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
Parametry
- s
- ReadOnlySpan<Char>
Rozsah obsahující znaky představující číslo, které se má převést. Rozsah se interpretuje pomocí stylu určeného parametrem style
.
- style
- NumberStyles
Bitová kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v s
. Typická hodnota, která se má zadat, je Integer.
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátování specifické pro s
jazykovou verzi. Pokud provider
je null
, použije se aktuální jazyková verze vlákna.
Návraty
Hodnota 8bitového podepsaného bajtů, která odpovídá číslu zadanému v parametru s
.
Implementuje
- Atributy
Platí pro
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)
- Zdroj:
- SByte.cs
- Zdroj:
- SByte.cs
Parsuje rozsah znaků UTF-8 na hodnotu.
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
Parametry
- utf8Text
- ReadOnlySpan<Byte>
Rozsah znaků UTF-8, které se mají analyzovat.
- style
- NumberStyles
Bitové kombinace stylů čísel, které se můžou vyskytovat v nástroji utf8Text
.
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátování specifické pro utf8Text
jazykovou verzi.
Návraty
Výsledek analýzy utf8Text
Implementuje
Platí pro
Parse(String, IFormatProvider)
- Zdroj:
- SByte.cs
- Zdroj:
- SByte.cs
- Zdroj:
- SByte.cs
Důležité
Toto rozhraní API neodpovídá specifikaci CLS.
- Alternativa odpovídající specifikaci CLS
- System.Int16.Parse(String)
Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na jeho 8bitový celočíselný ekvivalent.
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
Parametry
- s
- String
Řetězec, který představuje číslo, které chcete převést. Řetězec se interpretuje pomocí Integer stylu .
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátování specifické pro s
jazykovou verzi. Pokud provider
je null
, použije se aktuální jazyková verze vlákna.
Návraty
8bitové celé číslo se signedýmm adresou, které odpovídá číslu zadanému v s
.
Implementuje
- Atributy
Výjimky
s
je null
.
s
není ve správném formátu.
s
představuje číslo menší než SByte.MinValue nebo větší než SByte.MaxValue.
Příklady
Následující příklad definuje vlastní NumberFormatInfo objekt, který definuje vlnovku (~) jako záporné znaménko. Poté parsuje řadu číselných řetězců pomocí tohoto vlastního NumberFormatInfo objektu CultureInfo , stejně jako objekt, který představuje neutrální jazykovou verzi.
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'.
Poznámky
Parametr s
obsahuje číslo formuláře:
[ws] [sign] digits[ws]
Prvky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.
Element | Popis |
---|---|
Ws | Volitelné prázdné místo. |
sign | Nepovinný znak. |
Číslic | Řada číslic od 0 do 9. |
Parametr se s
interpretuje pomocí Integer stylu . Kromě desetinných číslic v bajtové hodnotě jsou povoleny pouze počáteční a koncové mezery s počátečním znaménkem. Pokud chcete explicitně definovat prvky stylu s informacemi o formátování specifické pro jazykovou verzi, které mohou být přítomny v s
, použijte metodu Parse(String, NumberStyles, IFormatProvider) .
Parametr provider
je IFormatProvider implementace, jejíž GetFormat metoda vrací NumberFormatInfo objekt, který poskytuje informace specifické pro jazykovou verzi s
formátu . Existují tři způsoby použití parametru provider
k poskytnutí informací o vlastním formátování do operace parsování:
Můžete předat skutečný NumberFormatInfo objekt, který poskytuje informace o formátování. (Jeho implementace jednoduše GetFormat vrátí sama sebe.)
Můžete předat CultureInfo objekt, který určuje jazykovou verzi, jejíž formátování se má použít. Jeho NumberFormat vlastnost poskytuje informace o formátování.
Můžete předat vlastní IFormatProvider implementaci. Jeho GetFormat metoda musí vytvořit instanci a vrátit NumberFormatInfo objekt, který poskytuje informace o formátování.
Pokud provider
je null
, použije se NumberFormatInfo objekt pro aktuální jazykovou verzi.
Viz také
Platí pro
Parse(String)
- Zdroj:
- SByte.cs
- Zdroj:
- SByte.cs
- Zdroj:
- SByte.cs
Důležité
Toto rozhraní API neodpovídá specifikaci CLS.
- Alternativa odpovídající specifikaci CLS
- System.Int16.Parse(String)
Převádí řetězcové vyjádření čísla na jeho ekvivalent v podobě 8bitového celého čísla se znaménkem.
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
Parametry
- s
- String
Řetězec, který představuje číslo, které chcete převést. Řetězec se interpretuje pomocí Integer stylu .
Návraty
8bitové celé číslo se signýmm číslem, které je ekvivalentní číslu obsaženému v parametru s
.
- Atributy
Výjimky
s
je null
.
s
neskládá se z volitelného znaménka následovaného posloupností číslic (nula až devět).
s
představuje číslo menší než SByte.MinValue nebo větší než SByte.MaxValue.
Příklady
Následující příklad ukazuje, jak převést řetězcovou hodnotu na hodnotu se sadou bajtů se sadou bajtů pomocí Parse metody . Výsledná hodnota podepsaného bajtu se pak zobrazí v konzole nástroje .
// 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.
Poznámky
Parametr s
obsahuje číslo formuláře:
[ws] [sign] digits[ws]
Prvky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.
Element | Popis |
---|---|
Ws | Volitelné prázdné místo. |
sign | Nepovinný znak. |
Číslic | Řada číslic od 0 do 9. |
Parametr se s
interpretuje pomocí NumberStyles.Integer stylu . Kromě desetinných číslic bajtové hodnoty jsou povoleny pouze počáteční a koncové mezery s kladným nebo záporným znaménkem na začátku. Chcete-li explicitně definovat prvky stylu, které mohou být přítomny v s
, použijte metodu Parse(String, NumberStyles)Parse(String, NumberStyles, IFormatProvider) nebo .
Parametr s
se parsuje pomocí informací o formátování v NumberFormatInfo inicializovaném souboru pro aktuální jazykovou verzi systému. Další informace naleznete v tématu NumberFormatInfo.CurrentInfo. Pokud chcete analyzovat řetězec pomocí informací o formátování nějaké jiné jazykové verze, použijte metodu Parse(String, NumberStyles, IFormatProvider) .
Viz také
Platí pro
Parse(ReadOnlySpan<Char>, IFormatProvider)
- Zdroj:
- SByte.cs
- Zdroj:
- SByte.cs
- Zdroj:
- SByte.cs
Parsuje rozsah znaků na hodnotu.
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
Parametry
- s
- ReadOnlySpan<Char>
Rozsah znaků, které se mají analyzovat.
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátování specifické pro s
jazykovou verzi.
Návraty
Výsledek analýzy s
Implementuje
Platí pro
Parse(ReadOnlySpan<Byte>, IFormatProvider)
- Zdroj:
- SByte.cs
- Zdroj:
- SByte.cs
Parsuje rozsah znaků UTF-8 na hodnotu.
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
Parametry
- utf8Text
- ReadOnlySpan<Byte>
Rozsah znaků UTF-8, které se mají analyzovat.
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátování specifické pro utf8Text
jazykovou verzi.
Návraty
Výsledek analýzy utf8Text
Implementuje
Platí pro
Parse(String, NumberStyles)
- Zdroj:
- SByte.cs
- Zdroj:
- SByte.cs
- Zdroj:
- SByte.cs
Důležité
Toto rozhraní API neodpovídá specifikaci CLS.
- Alternativa odpovídající specifikaci CLS
- System.Int16.Parse(String)
Převede řetězcové vyjádření čísla v zadaném stylu na jeho 8bitové celočíselné číslo.
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
Parametry
- s
- String
Řetězec obsahující číslo k převedení. Řetězec se interpretuje pomocí stylu určeného parametrem style
.
- style
- NumberStyles
Bitová kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v s
. Typická hodnota, která se má zadat, je Integer.
Návraty
8bitové celé číslo se signedýmm adresou, které odpovídá číslu zadanému v s
.
- Atributy
Výjimky
s
je null
.
s
není ve formátu, který je kompatibilní s style
.
s
představuje číslo menší než SByte.MinValue nebo větší než SByte.MaxValue.
-nebo-
s
zahrnuje nenulové desetinné číslice.
Příklady
Následující příklad parsuje řetězcové SByte reprezentace hodnot pomocí Parse(String, NumberStyles) metody . Aktuální jazyková verze pro daný příklad je 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.
Poznámky
Parametr style
definuje prvky stylu (například prázdné znaky nebo symbol kladného nebo záporného znaménka), které jsou povoleny v parametru s
pro úspěšnou operaci analýzy. Musí se jednat o kombinaci bitových příznaků z výčtu NumberStyles .
V závislosti na hodnotě style
s
může parametr obsahovat následující prvky:
[ws] [$][sign]digits[.fractional_digits][E[sign]exponential_digits][ws]
Pokud style
obsahuje NumberStyles.AllowHexSpecifierparametr , s
může parametr obsahovat následující prvky:
[ws] hexdigits[ws]
Prvky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.
Element | Popis |
---|---|
Ws | Volitelné prázdné místo. Prázdné znaky se můžou zobrazit na začátku, s pokud style obsahuje NumberStyles.AllowLeadingWhite příznak, a můžou se zobrazit na konci s , pokud styl příznak obsahuje NumberStyles.AllowTrailingWhite . |
$ | Symbol měny pro konkrétní jazykovou verzi. Jeho pozice v řetězci je definována NumberFormatInfo.CurrencyPositivePattern vlastností aktuální jazykové verze. Symbol měny aktuální jazykové verze se může zobrazit v s , pokud style obsahuje NumberStyles.AllowCurrencySymbol příznak . |
sign | Nepovinný znak. Znaménko se může zobrazit na začátku, s pokud style obsahuje NumberStyles.AllowLeadingSign příznak, a může se zobrazit na konci, s pokud style obsahuje NumberStyles.AllowTrailingSign příznak. Závorky lze v s použít k označení záporné hodnoty, pokud style obsahuje NumberStyles.AllowParentheses příznak. |
Číslic | Řada číslic od 0 do 9. |
. | Symbol desetinné čárky specifický pro jazykovou verzi. Symbol desetinné čárky aktuální jazykové verze se může zobrazit v s , pokud style obsahuje NumberStyles.AllowDecimalPoint příznak . |
Fractional_digits | Jeden nebo více výskytů číslice 0-9, pokud style obsahuje NumberStyles.AllowExponent příznak, nebo jeden nebo více výskytů číslice 0, pokud není. Desetinné číslice se můžou zobrazit jen v s případě, že style NumberStyles.AllowDecimalPoint obsahuje příznak . |
E | Znak "e" nebo "E", který určuje, že hodnota je reprezentován v exponenciální (vědecké) notaci. Parametr s může představovat číslo v exponenciálním zápisuNumberStyles.AllowExponent, pokud style obsahuje příznak . |
exponential_digits | Jeden nebo více výskytů číslice 0-9. Parametr s může představovat číslo v exponenciálním zápisuNumberStyles.AllowExponent, pokud style obsahuje příznak . |
hexdigits | Posloupnost šestnáctkových číslic od 0 do f nebo id 0 do F. |
Poznámka
Operace analýzy ignoruje všechny ukončující znaky s
NUL (U+0000) bez ohledu na hodnotu argumentu style
.
Řetězec pouze s desítkovými číslicemi (který odpovídá NumberStyles.None stylu) se vždy úspěšně parsuje. Většina zbývajících NumberStyles členů řídí prvky, které mohou být přítomny, ale nemusí být přítomny, ve vstupním řetězci. Následující tabulka uvádí, jak jednotlivé NumberStyles členy ovlivňují prvky, které mohou být přítomny v s
nástroji .
Nesložené hodnoty NumberStyles | Prvky povolené v s kromě číslic |
---|---|
NumberStyles.None | Pouze desítkové číslice. |
NumberStyles.AllowDecimalPoint | Desetinná čárka (.) a fractional_digits prvky. Pokud style však příznak neobsahuje NumberStyles.AllowExponent , musí fractional_digits obsahovat pouze jednu nebo více číslic. V opačném případě OverflowException je vyvolán znak . |
NumberStyles.AllowExponent | Znak "e" nebo "E", který označuje exponenciální zápis spolu s exponential_digits. |
NumberStyles.AllowLeadingWhite | Element ws na začátku .s |
NumberStyles.AllowTrailingWhite | Element ws na konci .s |
NumberStyles.AllowLeadingSign | Kladné znaménko před číslicemi |
NumberStyles.AllowTrailingSign | Kladné znaménko za číslicemi |
NumberStyles.AllowParentheses | Element sign ve formě závorek ohraničující číselnou hodnotu. |
NumberStyles.AllowThousands | Prvek oddělovače skupin (,). I když se oddělovač skupin může zobrazit v s souboru , musí mu předcházet pouze jedna nebo více číslic 0. |
NumberStyles.AllowCurrencySymbol | Element currency ($). |
Pokud se NumberStyles.AllowHexSpecifier použije příznak, s
musí to být šestnáctková hodnota. Platné šestnáctkové číslice jsou 0-9, a-f a A-F. Předpona 0x se nepodporuje a způsobí selhání operace analýzy. Jedinými dalšími příznaky, které je možné zkombinovat, style
jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles obsahuje složený styl čísla , NumberStyles.HexNumberkterý obsahuje oba příznaky prázdných znaků.)
Poznámka
s
Pokud je parametr řetězcovým vyjádřením šestnáctkového čísla, nemůže mu předcházet žádné dekorace (například 0x
nebo &h
), které ho odlišují jako šestnáctkové číslo. To způsobí, že operace analýzy vyvolá výjimku.
Pokud s
představuje šestnáctkové číslo, Parse(String, NumberStyles) metoda interpretuje bit ve vysokém pořadí bajtu jako znaménkový bit.
Parametr s
je analyzován pomocí informací o formátování v objektu NumberFormatInfo , který je inicializován pro aktuální jazykovou verzi systému. Chcete-li použít informace o formátování jiné jazykové verze, zavolejte Parse(String, NumberStyles, IFormatProvider) přetížení.
Viz také
Platí pro
Váš názor
https://aka.ms/ContentUserFeedback.
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu:Odeslat a zobrazit názory pro