SByte.Parse Metoda

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

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

Přetížení

Name	Description
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 znakem style.

style

NumberStyles

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

provider

IFormatProvider

Objekt, který poskytuje informace o sformátování specifické pro jazykovou verzi . Pokud provider ano null, použije se aktuální jazyková verze vlákna.

Návraty

SByte

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

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

[ws][$][znaménko]digits[.fractional_digits][E[sign]exponential_digits][ws]

Pokud style tento parametr obsahuje AllowHexSpecifier, s může 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é znaky. Prázdné znaky se můžou objevit na začátku s , pokud style příznak obsahuje NumberStyles.AllowLeadingWhite , a může se zobrazit na konci s , pokud style příznak NumberStyles.AllowTrailingWhite obsahuje.
$	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 případě, že style obsahuje NumberStyles.AllowCurrencySymbol příznak.
znaménko	Volitelné znaménko. Znaménko se může zobrazit na začátku s , pokud style příznak obsahuje NumberStyles.AllowLeadingSign , a může se zobrazit na konci příznaku s , pokud style příznak NumberStyles.AllowTrailingSign obsahuje. Závorky lze použít s k označení záporné hodnoty, pokud style obsahuje NumberStyles.AllowParentheses příznak.
Číslic	Posloupnost číslic od 0 do 9.
.	Symbol desetinné čárky specifické pro jazykovou verzi. Symbol desetinné čárky aktuální jazykové verze se může zobrazit, s pokud style příznak obsahuje NumberStyles.AllowDecimalPoint .
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 ne. Desetinná číslice se můžou zobrazovat s jenom v případě, že style příznak obsahuje 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ápisustyle, pokud NumberStyles.AllowExponent obsahuje příznak.
exponential_digits	Posloupnost číslic od 0 do 9. Parametr s může představovat číslo v exponenciálním zápisustyle, pokud NumberStyles.AllowExponent obsahuje příznak.
hexdigits	Posloupnost šestnáctkových číslic od 0 do f nebo 0 až F.

Poznámka

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

Řetězec 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ů 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.

Neseparované 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 neobsahuje NumberStyles.AllowExponent příznak, fractional_digits se musí skládat pouze z jednoho nebo více 0 číslic; jinak OverflowException je vyvolán znak.
NumberStyles.AllowExponent	Znak "e" nebo "E", který označuje exponenciální notaci spolu s exponential_digits.
NumberStyles.AllowLeadingWhite	Element 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 za číslicemi.
NumberStyles.AllowParentheses	Závorky před a za číslicemi označují zápornou hodnotu.
NumberStyles.AllowThousands	Element oddělovače skupin (,). I když se oddělovač skupin může objevit, smusí před ním být pouze jedna nebo více číslic.
NumberStyles.AllowCurrencySymbol	Prvek měny ($)

NumberStyles.AllowHexSpecifier Pokud se příznak použije, s musí být šestnáctková hodnota. Platné šestnáctkové číslice jsou 0-9, a-f a A-F. Jediné ostatní příznaky, které lze kombinovat s ním 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ězcovou reprezentací šestnáctkového čísla, nemůže mu předcházet žádná dekorace (například 0x nebo&h), která ji 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 bajtů ve vysokém pořadí jako bit znaménka.

Parametr provider je IFormatProvider implementace, jejíž GetFormat metoda vrací NumberFormatInfo objekt, který poskytuje informace specifické pro jazykovou verzi o 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ý NumberFormatInfo objekt, který poskytuje informace o formátování. (Její implementace GetFormat jednoduše 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 ano null, NumberFormatInfo použije se 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 čí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 parametrem style.

style

NumberStyles

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

provider

IFormatProvider

Objekt, který poskytuje informace o sformátování specifické pro jazykovou verzi . Pokud provider ano null, použije se aktuální jazyková verze vlákna.

Návraty

SByte

8bitová bajtů podepsaná 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 utf8Textformátování specifické pro jazykovou 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ě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í Integer stylu.

provider

IFormatProvider

Objekt, který poskytuje informace o sformátování specifické pro jazykovou verzi . Pokud provider ano null, 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 několik číselných řetězců pomocí tohoto vlastního NumberFormatInfoCultureInfo objektu a také 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][znaménko]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é znaky.
znaménko	Volitelné znaménko.
Číslic	Posloupnost číslic v rozsahu od 0 do 9

Parametr s se interpretuje pomocí Integer stylu. 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 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 o 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ý NumberFormatInfo objekt, který poskytuje informace o formátování. (Její implementace GetFormat jednoduše 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 ano null, NumberFormatInfo použije se 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ř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í Integer stylu.

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 pomocí metody převést řetězcovou hodnotu na podepsanou bajtovou hodnotu Parse . 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]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é znaky.
znaménko	Volitelné znaménko.
Číslic	Posloupnost číslic v rozsahu od 0 do 9

Parametr s se interpretuje pomocí NumberStyles.Integer stylu. 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 s, použijte buď metodu Parse(String, NumberStyles) nebo metodu Parse(String, NumberStyles, IFormatProvider) .

Parametr s je analyzován pomocí informací o formátování v inicializované pro NumberFormatInfo aktuální systémovou jazykovou verzi. Další informace najdete na webu 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 .NET
• Typy formátování v .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 sformátování specifické pro jazykovou 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 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 utf8Textformátování specifické pro jazykovou 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ě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 znakem style.

style

NumberStyles

Bitová kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v s. Typická hodnota, kterou je třeba zadat, 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í AllowHexSpecifier a HexNumber hodnot.

Příklady

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

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

[ws][$][znaménko]digits[.fractional_digits][E[sign]exponential_digits][ws]

Pokud style obsahuje NumberStyles.AllowHexSpecifierparametr, s může 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é znaky. Prázdné znaky se můžou objevit na začátku s , pokud style příznak obsahuje NumberStyles.AllowLeadingWhite , a může se zobrazit na konci s stylu, pokud tento NumberStyles.AllowTrailingWhite příznak obsahuje.
$	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 případě, že style obsahuje NumberStyles.AllowCurrencySymbol příznak.
znaménko	Volitelné znaménko. Znaménko se může zobrazit na začátku s , pokud style příznak obsahuje NumberStyles.AllowLeadingSign , a může se zobrazit na konci s , pokud style příznak NumberStyles.AllowTrailingSign obsahuje. Závorky lze použít s k označení záporné hodnoty, pokud style obsahuje NumberStyles.AllowParentheses příznak.
Číslic	Posloupnost číslic od 0 do 9.
.	Symbol desetinné čárky specifické pro jazykovou verzi. Symbol desetinné čárky aktuální jazykové verze se může zobrazit, s pokud style příznak obsahuje NumberStyles.AllowDecimalPoint .
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 ne. Desetinná číslice se můžou zobrazovat s jenom v případě, že style příznak obsahuje 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ápisustyle, pokud NumberStyles.AllowExponent 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ápisustyle, pokud NumberStyles.AllowExponent obsahuje příznak.
hexdigits	Posloupnost šestnáctkových číslic od 0 do f nebo 0 až F.

Poznámka

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

Řetězec 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ů ovládacích prvků, 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 fractional_digits elementy. Pokud style však příznak neobsahuje NumberStyles.AllowExponent , fractional_digits se musí skládat pouze z jednoho nebo více 0 číslic; jinak OverflowException je vyvolán znak.
NumberStyles.AllowExponent	Znak "e" nebo "E", který označuje exponenciální notaci spolu s exponential_digits.
NumberStyles.AllowLeadingWhite	Element 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 za číslicemi.
NumberStyles.AllowParentheses	Prvek znaménka 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, smusí před ním být pouze jedna nebo více číslic.
NumberStyles.AllowCurrencySymbol	Prvek měny ($)

NumberStyles.AllowHexSpecifier Pokud se příznak použije, 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, 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ězcovou reprezentací šestnáctkového čísla, nemůže mu předcházet žádná dekorace (například 0x nebo&h), která ji 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 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 .NET
• Typy formátování v .NET