SByte.Parse Metoda

Definice

Obor názvů:

System

Sestavení:

System.Runtime.dll

Převede řetězcové vyjádření čísla na jeho 8bitové celé číslo se znaky.

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 čísla v zadaném stylu a jazykové verzi na 8bitový ekvivalent.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Parsuje rozsah znaků UTF-8 do hodnoty.
Parse(String, IFormatProvider)	Převede řetězcové vyjádření čísla v zadaném formátu specifickém pro jazykovou verzi na jeho 8bitové celé číslo se znaky.
Parse(String)	Převede řetězcové vyjádření čísla na jeho 8bitové celé číslo se znaky.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsuje rozsah znaků do hodnoty.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Parsuje rozsah znaků UTF-8 do hodnoty.
Parse(String, NumberStyles)	Převede řetězcovou reprezentaci čísla v zadaném stylu na 8bitový ekvivalent celého čísla 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ý ekvivalent se znaky.

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, které chcete převést. Řetězec je interpretován pomocí stylu určeného style.

style

NumberStyles

Bitová kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v s. Typická hodnota pro zadání je Integer.

provider

IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi o s. Pokud je providernull, použije se aktuální jazyková verze vlákna.

Návraty

SByte

8bitová podepsaná bajtová hodnota, 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í Parse(String, NumberStyles, IFormatProvider) metoda k převodu různých řetězcových reprezentací čísel na podepsané celočíselné hodnoty.

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 povolené v parametru s, aby operace analýzy byla úspěšná. Musí se jednat o kombinaci bitových příznaků z NumberStyles výčtu.

V závislosti na hodnotě stylemůže parametr s obsahovat následující prvky:

[ws] [$] [znaménko]číslice[.fractional_digits][E[znaménko]exponential_digits][ws]

Pokud style obsahuje AllowHexSpecifier, může parametr s obsahovat následující prvky:

[ws]šestnáctkové[ws]

Prvky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element	Popis
ws	Volitelné prázdné znaky. Prázdné znaky se můžou objevit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingWhite a může se zobrazit na konci s, pokud style obsahuje příznak NumberStyles.AllowTrailingWhite.
$	Symbol měny specifický pro 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 příznak NumberStyles.AllowCurrencySymbol.
znaménko	Volitelné znaménko. Znaménko se může zobrazit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingSign a může se zobrazit konec s, pokud style obsahuje příznak NumberStyles.AllowTrailingSign. Závorky lze použít v s k označení záporné hodnoty, pokud style obsahuje příznak NumberStyles.AllowParentheses.
číslice	Posloupnost čí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 příznak NumberStyles.AllowDecimalPoint.
fractional_digits	Jeden nebo více výskytů číslice 0-9, pokud style obsahuje příznak NumberStyles.AllowExponent nebo jeden nebo více výskytů číslice 0, pokud ne. Desetinná číslice se můžou v s zobrazovat jenom v případě, že style obsahuje příznak NumberStyles.AllowDecimalPoint.
E	Znak "e" nebo "E", který označuje, že hodnota je reprezentována exponenciálním (vědeckým) zápisem. Parametr s může představovat číslo v exponenciálním zápisu, pokud style obsahuje příznak NumberStyles.AllowExponent.
exponential_digits	Posloupnost číslic od 0 do 9. Parametr s může představovat číslo v exponenciálním zápisu, pokud style obsahuje příznak NumberStyles.AllowExponent.
šestnáctkové	Posloupnost šestnáctkových číslic od 0 do f nebo 0 až F.

Poznámka

Všechny ukončující NUL (U+0000) znaky v s jsou ignorovány operací analýzy bez ohledu na hodnotu argumentu style.

Řetězec s desetinnými číslicemi (který odpovídá stylu NumberStyles.None) se vždy úspěšně parsuje. Většina zbývajících NumberStyles členů ovládacích prvků, které mohou být přítomny, ale nemusí být 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 s.

Neseloženého NumberStyles hodnot	Prvky povolené v s kromě číslic
NumberStyles.None	Pouze desítkové číslice.
NumberStyles.AllowDecimalPoint	Desetinná čárka (.) a prvky fractional_digits. Pokud však styl neobsahuje příznak NumberStyles.AllowExponent, fractional_digits musí obsahovat pouze jednu nebo více 0 číslic; v opačném případě je vyvolán OverflowException.
NumberStyles.AllowExponent	Znak "e" nebo "E", který označuje exponenciální notaci spolu s exponential_digits.
NumberStyles.AllowLeadingWhite	Prvek ws na začátku s.
NumberStyles.AllowTrailingWhite	Prvek ws na konci s.
NumberStyles.AllowLeadingSign	Kladné znaménko před číslicemi.
NumberStyles.AllowTrailingSign	Kladné znaménko po číslicích.
NumberStyles.AllowParentheses	Závorky před a za číslice označují zápornou hodnotu.
NumberStyles.AllowThousands	Oddělovač skupin (,) – element. I když se oddělovač skupin může objevit v s, musí mu předcházet pouze jeden nebo více 0 číslic.
NumberStyles.AllowCurrencySymbol	Prvek měny ($).

Pokud se používá příznak NumberStyles.AllowHexSpecifier, 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é lze kombinovat s ním, jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles zahrnuje složený styl čísla, NumberStyles.HexNumber, který obsahuje oba příznaky prázdných znaků.)

Poznámka

Pokud je parametr s řetězcovou reprezentací šestnáctkového čísla, nemůže mu předcházet žádný dekor (například 0x nebo &h), který ho rozlišuje jako šestnáctkové číslo. To způsobí, že operace analýzy vyvolá výjimku.

Pokud s představuje šestnáctkové číslo, metoda Parse(String, NumberStyles) interpretuje bit bajtů ve vysokém pořadí jako bit znaménka.

Parametr provider je IFormatProvider implementace, jejíž metoda GetFormat vrací objekt NumberFormatInfo, který poskytuje informace specifické pro jazykovou verzi formátu s. Existují tři způsoby použití parametru provider k zadání vlastních informací o formátování do operace analýzy:

• Můžete předat skutečný objekt NumberFormatInfo, který poskytuje informace o formátování. (Její implementace GetFormat jednoduše vrátí sama sebe.)

• Můžete předat objekt CultureInfo, který určuje jazykovou verzi, jejíž formátování se má použít. Jeho vlastnost NumberFormat 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 je providernull, použije se objekt NumberFormatInfo 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 čísla v zadaném stylu a jazykové verzi na 8bitový ekvivalent.

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 je interpretován pomocí stylu určeného style.

style

NumberStyles

Bitová kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v s. Typická hodnota pro zadání je Integer.

provider

IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi o s. Pokud je providernull, použije se aktuální jazyková verze vlákna.

Návraty

SByte

8bitová podepsaná bajtová hodnota, 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 do hodnoty.

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 pro analýzu.

style

NumberStyles

Bitové kombinace stylů čísel, které mohou být přítomny v utf8Text.

provider

IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi o utf8Text.

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ězcové vyjádření čísla v zadaném formátu specifickém pro jazykovou verzi na jeho 8bitové celé číslo se znaky.

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í stylu Integer.

provider

IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi o s. Pokud je providernull, použije se aktuální jazyková verze vlákna.

Návraty

SByte

8bitové celé číslo se signedm, které je ekvivalentní čí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. Pak parsuje řadu číselných řetězců pomocí tohoto vlastního objektu NumberFormatInfo i objektu CultureInfo, 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] [znaménko]číslice[ws]

Prvky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element	Popis
ws	Volitelné prázdné znaky.
znaménko	Volitelné znaménko.
číslice	Posloupnost číslic v rozsahu od 0 do 9

Parametr s se interpretuje pomocí stylu Integer. Kromě desetinných číslic bajtové hodnoty jsou povoleny pouze počáteční a koncové mezery s počátečním znakem. Chcete-li 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íž metoda GetFormat vrací objekt NumberFormatInfo, který poskytuje informace specifické pro jazykovou verzi formátu s. Existují tři způsoby použití parametru provider k zadání vlastních informací o formátování do operace analýzy:

• Můžete předat skutečný objekt NumberFormatInfo, který poskytuje informace o formátování. (Její implementace GetFormat jednoduše vrátí sama sebe.)

• Můžete předat objekt CultureInfo, který určuje jazykovou verzi, jejíž formátování se má použít. Jeho vlastnost NumberFormat 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 je providernull, použije se objekt NumberFormatInfo pro aktuální jazykovou verzi.

Viz také

• ToString()
• TryParse
• analýza číselných řetězců v rozhraní .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řevede řetězcové vyjádření čísla na jeho 8bitové celé číslo se znaky.

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í stylu Integer.

Návraty

SByte

8bitové celé číslo se signedm, které odpovídá číslu obsaženému v parametru s.

Výjimky

ArgumentException

s je null.

FormatException

s neobsahuje volitelné znaménko následované 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 podepsanou bajtovou hodnotu pomocí Parse metoda. Výsledná podepsaná bajtová hodnota se pak zobrazí v konzole.

// 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] [znaménko]číslice[ws]

Prvky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element	Popis
ws	Volitelné prázdné znaky.
znaménko	Volitelné znaménko.
číslice	Posloupnost číslic v rozsahu od 0 do 9

Parametr s se interpretuje pomocí stylu NumberStyles.Integer. Kromě desetinných číslic bajtové hodnoty jsou povoleny pouze počáteční a koncové mezery s počátečním kladným nebo záporným znaménkem. Chcete-li explicitně definovat prvky stylu, které mohou být přítomny v s, použijte Parse(String, NumberStyles) nebo Parse(String, NumberStyles, IFormatProvider) metoda.

Parametr s je analyzován pomocí informací o formátování v NumberFormatInfo, který je inicializován pro aktuální systémovou jazykovou verzi. Další informace najdete v tématu NumberFormatInfo.CurrentInfo. K analýze řetězce pomocí informací o formátování některé jiné jazykové verze použijte metodu Parse(String, NumberStyles, IFormatProvider).

Viz také

• analýza číselných řetězců v rozhraní .NET
• typy formátování v rozhraní .NET

Parse(ReadOnlySpan<Char>, IFormatProvider)

Zdroj:

SByte.cs

Parsuje rozsah znaků do hodnoty.

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 jazykovou verzi o s.

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 do hodnoty.

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 pro analýzu.

provider

IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi o utf8Text.

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ězcovou reprezentaci čísla v zadaném stylu na 8bitový ekvivalent celého čísla se znaky.

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, které se má převést. Řetězec se interpretuje pomocí stylu určeného style.

style

NumberStyles

Bitová kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v s. Typická hodnota pro zadání je Integer.

Návraty

SByte

8bitové celé číslo se signedm, které je ekvivalentní čí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 obsahuje nenulové desetinné číslice.

ArgumentException

style není NumberStyles hodnota.

-nebo-

style není kombinací hodnot AllowHexSpecifier a HexNumber.

Příklady

Následující příklad analyzuje řetězcové reprezentace hodnot SByte pomocí Parse(String, NumberStyles) metody. Aktuální jazyková verze pro 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 povolené v parametru s, aby operace analýzy byla úspěšná. Musí se jednat o kombinaci bitových příznaků z NumberStyles výčtu.

V závislosti na hodnotě stylemůže parametr s obsahovat následující prvky:

[ws] [$] [znaménko]číslice[.fractional_digits][E[znaménko]exponential_digits][ws]

Pokud style obsahuje NumberStyles.AllowHexSpecifier, může parametr s obsahovat následující prvky:

[ws]šestnáctkové[ws]

Prvky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element	Popis
ws	Volitelné prázdné znaky. Prázdné znaky se můžou objevit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingWhite a může se zobrazit na konci s pokud styl obsahuje příznak NumberStyles.AllowTrailingWhite.
$	Symbol měny specifický pro 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 příznak NumberStyles.AllowCurrencySymbol.
znaménko	Volitelné znaménko. Znaménko se může zobrazit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingSign a může se zobrazit na konci s, pokud style obsahuje příznak NumberStyles.AllowTrailingSign. Závorky lze použít v s k označení záporné hodnoty, pokud style obsahuje příznak NumberStyles.AllowParentheses.
číslice	Posloupnost čí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 příznak NumberStyles.AllowDecimalPoint.
fractional_digits	Jeden nebo více výskytů číslice 0-9, pokud style obsahuje příznak NumberStyles.AllowExponent nebo jeden nebo více výskytů číslice 0, pokud ne. Desetinná číslice se můžou v s zobrazovat jenom v případě, že style obsahuje příznak NumberStyles.AllowDecimalPoint.
E	Znak "e" nebo "E", který označuje, že hodnota je reprezentována exponenciálním (vědeckým) zápisem. Parametr s může představovat číslo v exponenciálním zápisu, pokud style obsahuje příznak NumberStyles.AllowExponent.
exponential_digits	Jeden nebo více výskytů číslice 0-9. Parametr s může představovat číslo v exponenciálním zápisu, pokud style obsahuje příznak NumberStyles.AllowExponent.
šestnáctkové	Posloupnost šestnáctkových číslic od 0 do f nebo 0 až F.

Poznámka

Všechny ukončující NUL (U+0000) znaky v s jsou ignorovány operací analýzy bez ohledu na hodnotu argumentu style.

Řetězec s desetinnými číslicemi (který odpovídá stylu NumberStyles.None) se vždy úspěšně parsuje. Většina zbývajících NumberStyles členů ovládací 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.

Neseparované hodnoty NumberStyles	Prvky povolené v s kromě číslic
NumberStyles.None	Pouze desítkové číslice.
NumberStyles.AllowDecimalPoint	Desetinná čárka (.) a prvky fractional_digits. Pokud však style neobsahuje příznak NumberStyles.AllowExponent, musí fractional_digits obsahovat pouze jednu nebo více číslic; v opačném případě je vyvolán OverflowException.
NumberStyles.AllowExponent	Znak "e" nebo "E", který označuje exponenciální notaci spolu s exponential_digits.
NumberStyles.AllowLeadingWhite	Prvek ws na začátku s.
NumberStyles.AllowTrailingWhite	Prvek ws na konci s.
NumberStyles.AllowLeadingSign	Kladné znaménko před číslicemi.
NumberStyles.AllowTrailingSign	Kladné znaménko po číslicích.
NumberStyles.AllowParentheses	Znak prvek ve formě závorek ohraničující číselnou hodnotu.
NumberStyles.AllowThousands	Element oddělovače skupin (,). I když se oddělovač skupin může objevit v s, musí mu předcházet pouze jeden nebo více 0 číslic.
NumberStyles.AllowCurrencySymbol	Prvek měny ($).

Pokud se používá příznak NumberStyles.AllowHexSpecifier, s musí být šestnáctková hodnota. Platné šestnáctkové číslice jsou 0-9, a-f a A-F. Předpona, například 0x, není podporována a způsobí selhání operace analýzy. Jedinými dalšími příznaky, které lze kombinovat v style, jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles zahrnuje složený styl čísla, NumberStyles.HexNumber, který obsahuje oba příznaky prázdných znaků.)

Poznámka

Pokud je parametr s řetězcovou reprezentací šestnáctkového čísla, nemůže mu předcházet žádný dekor (například 0x nebo &h), který ho rozlišuje jako šestnáctkové číslo. To způsobí, že operace analýzy vyvolá výjimku.

Pokud s představuje šestnáctkové číslo, metoda Parse(String, NumberStyles) interpretuje bit bajtů ve vysokém pořadí jako bit znaménka.

Parametr s je analyzován pomocí informací o formátování v objektu NumberFormatInfo, který je inicializován pro aktuální systémovou jazykovou verzi. Chcete-li použít informace o formátování některé jiné jazykové verze, zavolejte Parse(String, NumberStyles, IFormatProvider) přetížení.

Viz také

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