SByte.Parse Metoda

Definice

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)

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

Parse(String, NumberStyles)

Převede řetězcovou reprezentaci čísla v zadaném stylu na jeho 8bitový celočíselné ekvivalent.

Parse(String, IFormatProvider)

Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na jeho 8bitový celočíselnou ekvivalent.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Převede reprezentaci čísla, které je v zadaném stylu a formátu specifickém pro jazykovou verzi, na jeho 8bitový ekvivalent.

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.

Parse(String)

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS
System.Int16.Parse(String)

Převádí řetězcové vyjádření čísla na jeho ekvivalent v podobě 8bitového celého čísla se znaménkem.

public:
 static System::SByte Parse(System::String ^ s);
[System.CLSCompliant(false)]
public static sbyte Parse (string s);
public static sbyte Parse (string s);
[<System.CLSCompliant(false)>]
static member Parse : string -> sbyte
static member Parse : string -> sbyte
Public Shared Function Parse (s As String) As SByte

Parametry

s
String

Řetězec, který představuje číslo, které se má převést. Řetězec se interpretuje pomocí Integer stylu.

Návraty

SByte

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

Atributy

Výjimky

s je null.

s neobsahuje nepovinný znaménko následované posloupností číslic (nula až devět).

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

Příklady

Následující příklad ukazuje, jak převést řetězcovou hodnotu na podepsanou bajtovou hodnotu pomocí Parse metody. 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é místo.
sign Nepovinný znak.
číslice Řada číslic 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 sv , použijte buď metoduParse(String, NumberStyles), nebo.Parse(String, NumberStyles, IFormatProvider)

Parametr s je analyzován pomocí informací o formátování v NumberFormatInfo inicializované pro aktuální systémovou jazykovou verzi. Další informace naleznete v tématu NumberFormatInfo.CurrentInfo. Pokud chcete analyzovat řetězec pomocí informací o formátování některé jiné jazykové verze, použijte metodu Parse(String, NumberStyles, IFormatProvider) .

Viz také

Platí pro

Parse(ReadOnlySpan<Char>, IFormatProvider)

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

provider
IFormatProvider

Návraty

SByte

Výsledek analýzy s.

Implementuje

Platí pro

Parse(String, NumberStyles)

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 jeho 8bitový celočíselné ekvivalent.

public:
 static System::SByte Parse(System::String ^ s, System::Globalization::NumberStyles style);
[System.CLSCompliant(false)]
public static sbyte Parse (string s, System.Globalization.NumberStyles style);
public static sbyte Parse (string s, System.Globalization.NumberStyles style);
[<System.CLSCompliant(false)>]
static member Parse : string * System.Globalization.NumberStyles -> sbyte
static member Parse : string * System.Globalization.NumberStyles -> sbyte
Public Shared Function Parse (s As String, style As NumberStyles) As SByte

Parametry

s
String

Řetězec obsahující číslo k převedení. Řetězec se interpretuje pomocí stylu určeného parametrem style.

style
NumberStyles

Bitové kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomné 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.

Atributy

Výjimky

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

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

-nebo- s obsahuje nenulové desetinné číslice.

style není NumberStyles hodnota.

-nebo-

style není kombinací AllowHexSpecifier a HexNumber hodnotami.

Příklady

Následující příklad parsuje řetězcové reprezentace SByte hodnot metodou Parse(String, NumberStyles) . 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 v parametru s povolené pro úspěšné parsování operace. 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énka]číslic[.fractional_digits][E[sign]exponential_digits][ws]

Pokud style parametr obsahuje NumberStyles.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 objevit na začátku s , pokud style obsahuje NumberStyles.AllowLeadingWhite příznak, a může se zobrazit na konci s stylu, pokud styl NumberStyles.AllowTrailingWhite obsahuje 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 případě, že 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 příznak obsahuje NumberStyles.AllowTrailingSign . Závorky lze použít s k označení záporné hodnoty, pokud style obsahuje NumberStyles.AllowParentheses příznak.
číslice Řada čí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 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 ne. 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 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

Všechny ukončující NUL (U+0000) znaky 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 nejsou nutné, aby byly 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.

Nesložené 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 neobsahujeNumberStyles.AllowExponent, fractional_digits se musí skládat pouze z jedné 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í zápis spolu s exponential_digits.
NumberStyles.AllowLeadingWhite Ws element na začátku s.
NumberStyles.AllowTrailingWhite Ws element 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 s číselnou hodnotou.
NumberStyles.AllowThousands Prvek oddělovače skupin (,). I když se oddělovač skupin může zobrazit s, musí před ním být pouze jedna nebo více číslic.
NumberStyles.AllowCurrencySymbol Element currency ($)

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, se nepodporuje a způsobí selhání operace analýzy. Jediné ostatní příznaky, které lze kombinovat, style 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řed ním být žá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 s vysokým pořadím bajtu jako bit znaménka.

Parametr s se analyzuje 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í některé jiné jazykové verze, zavolejte Parse(String, NumberStyles, IFormatProvider) přetížení.

Viz také

Platí pro

Parse(String, IFormatProvider)

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číselnou ekvivalent.

public:
 static System::SByte Parse(System::String ^ s, IFormatProvider ^ provider);
public:
 static System::SByte Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<System::SByte>::Parse;
[System.CLSCompliant(false)]
public static sbyte Parse (string s, IFormatProvider provider);
public static sbyte Parse (string s, IFormatProvider? provider);
[System.CLSCompliant(false)]
public static sbyte Parse (string s, IFormatProvider? provider);
[<System.CLSCompliant(false)>]
static member Parse : string * IFormatProvider -> sbyte
static member Parse : string * IFormatProvider -> sbyte
Public Shared Function Parse (s As String, provider As IFormatProvider) As SByte

Parametry

s
String

Řetězec, který představuje číslo, které se má převést. Řetězec se interpretuje pomocí Integer stylu.

provider
IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi .s 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

Atributy

Výjimky

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

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

Příklady

Následující příklad definuje vlastní NumberFormatInfo objekt, který definuje vlnovku (~) jako záporné znaménko. Potom analyzuje několik číselných řetězců pomocí tohoto vlastního NumberFormatInfo objektu i CultureInfo objektu, 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é místo.
sign Nepovinný znak.
číslice Řada číslic 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 znaménkem. 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í. (Jeho 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é

Platí pro

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Převede reprezentaci čísla, které je v zadaném stylu a formátu specifickém pro jazykovou verzi, na jeho 8bitový ekvivalent.

public static sbyte Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);
[System.CLSCompliant(false)]
public static sbyte Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider provider = default);
[System.CLSCompliant(false)]
public static sbyte Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);
static member Parse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider -> sbyte
[<System.CLSCompliant(false)>]
static member Parse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider -> sbyte
Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As SByte

Parametry

s
ReadOnlySpan<Char>

Rozsah obsahující znaky představující číslo, které se má převést. Rozsah se interpretuje pomocí stylu určeného parametrem style.

style
NumberStyles

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

provider
IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi .s 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

Atributy

Platí pro

Parse(String, NumberStyles, IFormatProvider)

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.

public:
 static System::SByte Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider);
public:
 static System::SByte Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<System::SByte>::Parse;
[System.CLSCompliant(false)]
public static sbyte Parse (string s, System.Globalization.NumberStyles style, IFormatProvider provider);
public static sbyte Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);
[System.CLSCompliant(false)]
public static sbyte Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);
[<System.CLSCompliant(false)>]
static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> sbyte
static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> sbyte
Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As SByte

Parametry

s
String

Řetězec obsahující číslo k převedení. Řetězec 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řítomné v s. Typická hodnota pro zadání je Integer.

provider
IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi .s 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

Atributy

Výjimky

style není NumberStyles hodnota.

-nebo-

style není kombinací AllowHexSpecifier a HexNumber.

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

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

-nebo- s obsahuje nenulové desetinné číslice.

Příklady

Následující příklad znázorňuje 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é pro úspěšné parsování operace. 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énka]číslic[.fractional_digits][E[sign]exponential_digits][ws]

Pokud style parametr 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é 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 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 případě, že 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 style příznaku NumberStyles.AllowTrailingSign . Závorky lze použít s k označení záporné hodnoty, pokud style obsahuje NumberStyles.AllowParentheses příznak.
číslice Řada čí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 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 ne. 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.
hexdigits Posloupnost šestnáctkových číslic od 0 do f nebo id 0 do F.

Poznámka

Všechny ukončující NUL (U+0000) znaků 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řítomné, ale v tomto vstupním řetězci není nutné je prezentovat. Následující tabulka uvádí, jak jednotlivé NumberStyles členy ovlivňují prvky, které mohou být přítomné v s.

Nesložených NumberStyles hodnot 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, musí fractional_digits obsahovat pouze jednu nebo více číslic; jinak OverflowException je vyvolán.
NumberStyles.AllowExponent Znak "e" nebo "E", který označuje exponenciální zápis spolu s exponential_digits.
NumberStyles.AllowLeadingWhite Ws element na začátku .s
NumberStyles.AllowTrailingWhite Ws element 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 skupiny (,). I když se oddělovač skupiny může zobrazit, smusí před ní být pouze jedna nebo více číslic.
NumberStyles.AllowCurrencySymbol Element 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 NumberStyles.HexNumberčísla, který obsahuje 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é dekoraci (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 s vysokým pořadím bajtu jako znaménko.

Parametr provider je IFormatProvider implementace, jejíž GetFormat metoda vrací NumberFormatInfo objekt, 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ý NumberFormatInfo objekt, který poskytuje informace o formátování. (Jeho implementace GetFormat jednoduše vrací 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.

Platí pro