SByte.Parse Metoda

Definice

Obor názvů:

System

Sestavení:

System.Runtime.dll

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

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) = 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

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

SByte

Hodnota 8bitového podepsaného bajtů, která odpovídá číslu zadanému v parametru s .

Implementuje

Parse(String, NumberStyles, IFormatProvider)

Výjimky

ArgumentException

style není NumberStyles hodnota.

-nebo-

style není kombinací AllowHexSpecifier a HexNumber.

ArgumentNullException

s je null.

FormatException

s není ve formátu, který je kompatibilní s style.

OverflowException

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ě styles 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 sformá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.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

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);

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 sjazykovou verzi. Pokud provider je null, použije se aktuální jazyková verze vlákna.

Návraty

SByte

Hodnota 8bitového podepsaného bajtů, která odpovídá číslu zadanému v parametru s .

Implementuje

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

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 utf8Textjazykovou verzi.

Návraty

SByte

Výsledek analýzy utf8Text

Implementuje

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parse(String, IFormatProvider)

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) = 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

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 sjazykovou verzi. Pokud provider je null, použije se aktuální jazyková verze vlákna.

Návraty

SByte

8bitové celé číslo se signedýmm adresou, které odpovídá číslu zadanému v s.

Implementuje

Parse(String, IFormatProvider)

Výjimky

ArgumentNullException

s je null.

FormatException

s není ve správném formátu.

OverflowException

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 sformá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é

• ToString()
• TryParse
• Analýza číselných řetězců v .NET

Parse(String)

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);

public static sbyte Parse (string s);

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

SByte

8bitové celé číslo se signýmm číslem, které je ekvivalentní číslu obsaženému v parametru s .

Výjimky

ArgumentException

s je null.

FormatException

s neskládá se z volitelného znaménka následovaného posloupností číslic (nula až devět).

OverflowException

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é

• Analýza číselných řetězců v .NET
• Typy formátování v .NET

Parse(ReadOnlySpan<Char>, IFormatProvider)

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 sjazykovou verzi.

Návraty

SByte

Výsledek analýzy s

Implementuje

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(ReadOnlySpan<Byte>, IFormatProvider)

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 utf8Textjazykovou verzi.

Návraty

SByte

Výsledek analýzy utf8Text

Implementuje

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parse(String, NumberStyles)

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);

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

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

SByte

8bitové celé číslo se signedýmm adresou, které odpovídá číslu zadanému v s.

Výjimky

ArgumentNullException

s je null.

FormatException

s není ve formátu, který je kompatibilní s style.

OverflowException

s představuje číslo menší než SByte.MinValue nebo větší než SByte.MaxValue.

-nebo-

s zahrnuje nenulové desetinné číslice.

ArgumentException

style není NumberStyles hodnota.

-nebo-

style není kombinací AllowHexSpecifier hodnot a HexNumber .

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ě styles 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 styleNumberStyles.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 sná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 ssouboru , 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é

• ToString()
• TryParse
• Analýza číselných řetězců v .NET
• Typy formátování v .NET