SByte.Parse Metoda

Definicja

Przestrzeń nazw:

System

Zestaw:

System.Runtime.dll

Konwertuje reprezentację ciągu liczby na 8-bitową liczbę całkowitą ze znakiem.

Przeciążenia

Parse(String, NumberStyles, IFormatProvider)	Konwertuje reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na jego 8-bitowy odpowiednik ze znakiem.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konwertuje reprezentację zakresu liczby w określonym stylu i formacie specyficznym dla kultury na jego 8-bitowy odpowiednik ze znakiem.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analizuje zakres znaków UTF-8 w wartość.
Parse(String, IFormatProvider)	Konwertuje reprezentację ciągu liczby w określonym formacie specyficznym dla kultury na 8-bitową liczbę całkowitą ze znakiem.
Parse(String)	Konwertuje reprezentację ciągu liczby na 8-bitową liczbę całkowitą ze znakiem.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analizuje zakres znaków w wartości.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analizuje zakres znaków UTF-8 w wartość.
Parse(String, NumberStyles)	Konwertuje reprezentację ciągu liczby w określonym stylu na 8-bitową liczbę całkowitą ze znakiem 8-bitowym.

Parse(String, NumberStyles, IFormatProvider)

Źródło:

SByte.cs

Ważne

Ten interfejs API nie jest zgodny ze specyfikacją CLS.

Alternatywa zgodna ze specyfikacją CLS

System.Int16.Parse(String, NumberStyles, IFormatProvider)

Konwertuje reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na jego 8-bitowy odpowiednik ze znakiem.

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

Ciąg zawierający liczbę do przekonwertowania. Ciąg jest interpretowany przy użyciu stylu określonego przez style.

style

NumberStyles

Bitowa kombinacja wartości wyliczenia wskazująca elementy stylu, które mogą być obecne w s. Typową wartością do określenia jest Integer.

provider

IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficznym dla kultury na temat s. Jeśli provider jest null, używana jest bieżąca kultura wątku.

Zwraca

SByte

8-bitowa wartość bajtu ze znakiem, która jest równoważna liczbie określonej w parametrze s.

Implementuje

Parse(String, NumberStyles, IFormatProvider)

Wyjątki

ArgumentException

style nie jest wartością NumberStyles.

-lub-

style nie jest kombinacją AllowHexSpecifier i HexNumber.

ArgumentNullException

s jest null.

FormatException

s nie jest w formacie zgodnym z style.

OverflowException

s reprezentuje liczbę mniejszą niż SByte.MinValue lub większą niż SByte.MaxValue.

-lub-

s zawiera cyfry niezerowe, ułamkowe.

Przykłady

Poniższy przykład ilustruje użycie metody Parse(String, NumberStyles, IFormatProvider) do konwertowania różnych reprezentacji ciągów liczb na podpisane wartości całkowite.

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

Uwagi

Parametr style definiuje elementy stylu (takie jak biały znak lub symbol znaku dodatniego lub ujemnego), które są dozwolone w parametrze s, aby operacja analizy zakończyła się pomyślnie. Musi to być kombinacja flag bitowych z wyliczenia NumberStyles.

W zależności od wartości styleparametr s może zawierać następujące elementy:

[ws] [$] [podpisywania] cyfry[.fractional_digits][E[podpisywania]exponential_digits][]

Jeśli style zawiera AllowHexSpecifier, parametr s może zawierać następujące elementy:

[ws]hexdigits[ws]

Elementy w nawiasach kwadratowych ([ i ]) są opcjonalne. W poniższej tabeli opisano każdy element.

Pierwiastek	Opis
ws	Opcjonalne białe znaki. Białe znaki mogą pojawić się na początku s, jeśli style zawiera flagę NumberStyles.AllowLeadingWhite i może pojawić się na końcu s, jeśli style zawiera flagę NumberStyles.AllowTrailingWhite.
$	Symbol waluty specyficznej dla kultury. Jego pozycja w ciągu jest definiowana przez właściwość NumberFormatInfo.CurrencyPositivePattern bieżącej kultury. Symbol waluty bieżącej kultury może pojawić się w s, jeśli style zawiera flagę NumberStyles.AllowCurrencySymbol.
podpisywania	Opcjonalny znak. Znak może pojawić się na początku s, jeśli style zawiera flagę NumberStyles.AllowLeadingSign i może pojawić się koniec s, jeśli style zawiera flagę NumberStyles.AllowTrailingSign. Nawiasy mogą być używane w s, aby wskazać wartość ujemną, jeśli style zawiera flagę NumberStyles.AllowParentheses.
cyfry	Sekwencja cyfr z zakresu od 0 do 9.
.	Symbol separatora dziesiętnego specyficznego dla kultury. Symbol punktu dziesiętnego bieżącej kultury może pojawić się w s, jeśli style zawiera flagę NumberStyles.AllowDecimalPoint.
fractional_digits	Co najmniej jedno wystąpienie cyfry 0–9, jeśli style zawiera flagę NumberStyles.AllowExponent lub co najmniej jedno wystąpienie cyfry 0, jeśli nie. Cyfry ułamkowe mogą być wyświetlane w s tylko wtedy, gdy style zawiera flagę NumberStyles.AllowDecimalPoint.
E	Znak "e" lub "E", który wskazuje, że wartość jest reprezentowana w notacji wykładniczej (naukowej). Parametr s może reprezentować liczbę w notacji wykładniczej, jeśli style zawiera flagę NumberStyles.AllowExponent.
exponential_digits	Sekwencja cyfr z zakresu od 0 do 9. Parametr s może reprezentować liczbę w notacji wykładniczej, jeśli style zawiera flagę NumberStyles.AllowExponent.
szesnastkowy	Sekwencja cyfr szesnastkowa od 0 do f lub od 0 do F.

Nuta

Wszystkie znaki NUL (U+0000) w s są ignorowane przez operację analizowania, niezależnie od wartości argumentu style.

Ciąg z cyframi dziesiętnymi (który odpowiada stylowi NumberStyles.None) zawsze jest analizowanych pomyślnie. Większość pozostałych elementów członkowskich NumberStyles, które mogą być obecne, ale nie muszą być obecne, w tym ciągu wejściowym. W poniższej tabeli przedstawiono, jak poszczególne elementy członkowskie NumberStyles wpływają na elementy, które mogą znajdować się w s.

Wartości NumberStyles niezwiązanych	Elementy dozwolone w s oprócz cyfr
NumberStyles.None	Tylko cyfry dziesiętne.
NumberStyles.AllowDecimalPoint	Punkt dziesiętny (.) i elementy fractional_digits. Jeśli jednak styl nie zawiera flagi NumberStyles.AllowExponent, fractional_digits musi zawierać tylko jedną lub więcej cyfr; w przeciwnym razie zostanie zgłoszony OverflowException.
NumberStyles.AllowExponent	Znak "e" lub "E", który wskazuje notację wykładniczą wraz z exponential_digits.
NumberStyles.AllowLeadingWhite	Element ws na początku s.
NumberStyles.AllowTrailingWhite	Element ws na końcu s.
NumberStyles.AllowLeadingSign	Znak dodatni przed cyframi.
NumberStyles.AllowTrailingSign	Znak dodatni po cyfrach.
NumberStyles.AllowParentheses	Nawiasy przed i po cyfr, aby wskazać wartość ujemną.
NumberStyles.AllowThousands	Element separatora grup (,). Chociaż separator grupy może być wyświetlany w s, musi być poprzedzony tylko jedną lub więcej cyfr.
NumberStyles.AllowCurrencySymbol	Element currency ($).

Jeśli jest używana flaga NumberStyles.AllowHexSpecifier, s musi być wartością szesnastkową. Prawidłowe cyfry szesnastkowe to 0–9, a-f i A-F. Jedynymi innymi flagami, które można połączyć z nim, są NumberStyles.AllowLeadingWhite i NumberStyles.AllowTrailingWhite. (Wyliczenie NumberStyles zawiera styl liczb złożonych, NumberStyles.HexNumber, który zawiera obie flagi odstępu).

Nuta

Jeśli parametr s jest reprezentacją ciągu liczby szesnastkowej, nie może być poprzedzony żadną dekoracją (taką jak 0x lub &h), która odróżnia ją jako liczbę szesnastkową. Powoduje to, że operacja analizy zgłasza wyjątek.

Jeśli s reprezentuje liczbę szesnastkową, metoda Parse(String, NumberStyles) interpretuje bit o wysokiej kolejności bajtu jako bit znaku.

Parametr provider to implementacja IFormatProvider, której metoda GetFormat zwraca obiekt NumberFormatInfo, który udostępnia informacje specyficzne dla kultury dotyczące formatu s. Istnieją trzy sposoby użycia parametru provider do podawania niestandardowych informacji formatowania do operacji analizowania:

• Można przekazać rzeczywisty obiekt NumberFormatInfo, który udostępnia informacje o formatowaniu. (Jego implementacja GetFormat po prostu zwraca się).

• Można przekazać obiekt CultureInfo określający kulturę, której formatowanie ma być używane. Jego właściwość NumberFormat zawiera informacje o formatowaniu.

• Możesz przekazać niestandardową implementację IFormatProvider. Metoda GetFormat musi utworzyć wystąpienie i zwrócić obiekt NumberFormatInfo, który udostępnia informacje o formatowaniu.

Jeśli provider jest null, używany jest obiekt NumberFormatInfo dla bieżącej kultury.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Źródło:

SByte.cs

Ważne

Ten interfejs API nie jest zgodny ze specyfikacją CLS.

Konwertuje reprezentację zakresu liczby w określonym stylu i formacie specyficznym dla kultury na jego 8-bitowy odpowiednik ze znakiem.

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>

Zakres zawierający znaki reprezentujące liczbę do przekonwertowania. Zakres jest interpretowany przy użyciu stylu określonego przez style.

style

NumberStyles

Bitowa kombinacja wartości wyliczenia wskazująca elementy stylu, które mogą być obecne w s. Typową wartością do określenia jest Integer.

provider

IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficznym dla kultury na temat s. Jeśli provider jest null, używana jest bieżąca kultura wątku.

Zwraca

SByte

8-bitowa wartość bajtu ze znakiem, która jest równoważna liczbie określonej w parametrze s.

Implementuje

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Źródło:

SByte.cs

Analizuje zakres znaków UTF-8 w wartość.

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>

Zakres znaków UTF-8 do przeanalizowania.

style

NumberStyles

Bitowa kombinacja stylów liczbowych, które mogą być obecne w utf8Text.

provider

IFormatProvider

Obiekt, który udostępnia informacje o formatowaniu specyficznym dla kultury na temat utf8Text.

Zwraca

SByte

Wynik analizowania utf8Text.

Implementuje

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parse(String, IFormatProvider)

Źródło:

SByte.cs

Ważne

Ten interfejs API nie jest zgodny ze specyfikacją CLS.

Alternatywa zgodna ze specyfikacją CLS

System.Int16.Parse(String)

Konwertuje reprezentację ciągu liczby w określonym formacie specyficznym dla kultury na 8-bitową liczbę całkowitą ze znakiem.

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

Ciąg reprezentujący liczbę do przekonwertowania. Ciąg jest interpretowany przy użyciu stylu Integer.

provider

IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficznym dla kultury na temat s. Jeśli provider jest null, używana jest bieżąca kultura wątku.

Zwraca

SByte

Liczba całkowita ze znakiem 8-bitowym, która jest równoważna liczbie określonej w s.

Implementuje

Parse(String, IFormatProvider)

Wyjątki

ArgumentNullException

s jest null.

FormatException

s nie jest w poprawnym formacie.

OverflowException

s reprezentuje liczbę mniejszą niż SByte.MinValue lub większą niż SByte.MaxValue.

Przykłady

W poniższym przykładzie zdefiniowano niestandardowy obiekt NumberFormatInfo definiujący tyldę (~) jako znak ujemny. Następnie analizuje liczbę ciągów liczbowych przy użyciu tego niestandardowego obiektu NumberFormatInfo, a także obiektu CultureInfo, który reprezentuje niezmienną kulturę.

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'.

Uwagi

Parametr s zawiera liczbę formularzy:

[ws] [podpisywania]cyfry[ws]

Elementy w nawiasach kwadratowych ([ i ]) są opcjonalne. W poniższej tabeli opisano każdy element.

Pierwiastek	Opis
ws	Opcjonalne białe znaki.
podpisywania	Opcjonalny znak.
cyfry	Sekwencja cyfr od 0 do 9.

Parametr s jest interpretowany przy użyciu stylu Integer. Oprócz cyfr dziesiętnych wartości bajtów dozwolone są tylko spacje wiodące i końcowe z znakiem wiodącym. Aby jawnie zdefiniować elementy stylu przy użyciu informacji formatowania specyficznego dla kultury, które mogą być obecne w s, użyj metody Parse(String, NumberStyles, IFormatProvider).

Parametr provider to implementacja IFormatProvider, której metoda GetFormat zwraca obiekt NumberFormatInfo, który udostępnia informacje specyficzne dla kultury dotyczące formatu s. Istnieją trzy sposoby użycia parametru provider do podawania niestandardowych informacji formatowania do operacji analizowania:

• Można przekazać rzeczywisty obiekt NumberFormatInfo, który udostępnia informacje o formatowaniu. (Jego implementacja GetFormat po prostu zwraca się).

• Można przekazać obiekt CultureInfo określający kulturę, której formatowanie ma być używane. Jego właściwość NumberFormat zawiera informacje o formatowaniu.

• Możesz przekazać niestandardową implementację IFormatProvider. Metoda GetFormat musi utworzyć wystąpienie i zwrócić obiekt NumberFormatInfo, który udostępnia informacje o formatowaniu.

Jeśli provider jest null, używany jest obiekt NumberFormatInfo dla bieżącej kultury.

Zobacz też

• ToString()
• TryParse
• analizowanie ciągów liczbowych na platformie .NET

Parse(String)

Źródło:

SByte.cs

Ważne

Ten interfejs API nie jest zgodny ze specyfikacją CLS.

Alternatywa zgodna ze specyfikacją CLS

System.Int16.Parse(String)

Konwertuje reprezentację ciągu liczby na 8-bitową liczbę całkowitą ze znakiem.

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

Ciąg reprezentujący liczbę do przekonwertowania. Ciąg jest interpretowany przy użyciu stylu Integer.

Zwraca

SByte

Liczba całkowita ze znakiem 8-bitowym, która jest równoważna liczbie zawartej w parametrze s.

Wyjątki

ArgumentException

s jest null.

FormatException

s nie składa się z opcjonalnego znaku, po którym następuje sekwencja cyfr (zero do dziewięciu).

OverflowException

s reprezentuje liczbę mniejszą niż SByte.MinValue lub większą niż SByte.MaxValue.

Przykłady

W poniższym przykładzie pokazano, jak przekonwertować wartość ciągu na wartość bajtu ze znakiem przy użyciu metody Parse. Wynikowa wartość bajtu podpisanego jest następnie wyświetlana w konsoli programu .

// 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.

Uwagi

Parametr s zawiera liczbę formularzy:

[ws] [podpisywania]cyfry[ws]

Elementy w nawiasach kwadratowych ([ i ]) są opcjonalne. W poniższej tabeli opisano każdy element.

Pierwiastek	Opis
ws	Opcjonalne białe znaki.
podpisywania	Opcjonalny znak.
cyfry	Sekwencja cyfr od 0 do 9.

Parametr s jest interpretowany przy użyciu stylu NumberStyles.Integer. Oprócz cyfr dziesiętnych wartości bajtowej dozwolone są tylko spacje wiodące i końcowe z wiodącym znakiem dodatnim lub ujemnym. Aby jawnie zdefiniować elementy stylu, które mogą być obecne w s, użyj metody Parse(String, NumberStyles) lub Parse(String, NumberStyles, IFormatProvider).

Parametr s jest analizowany przy użyciu informacji o formatowaniu w NumberFormatInfo zainicjowanej dla bieżącej kultury systemu. Aby uzyskać więcej informacji, zobacz NumberFormatInfo.CurrentInfo. Aby przeanalizować ciąg przy użyciu informacji o formatowaniu innej kultury, użyj metody Parse(String, NumberStyles, IFormatProvider).

Zobacz też

• analizowanie ciągów liczbowych na platformie .NET
• typy formatowania na platformie .NET

Parse(ReadOnlySpan<Char>, IFormatProvider)

Źródło:

SByte.cs

Analizuje zakres znaków w wartości.

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>

Zakres znaków do przeanalizowania.

provider

IFormatProvider

Obiekt, który udostępnia informacje o formatowaniu specyficznym dla kultury na temat s.

Zwraca

SByte

Wynik analizowania s.

Implementuje

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Źródło:

SByte.cs

Analizuje zakres znaków UTF-8 w wartość.

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>

Zakres znaków UTF-8 do przeanalizowania.

provider

IFormatProvider

Obiekt, który udostępnia informacje o formatowaniu specyficznym dla kultury na temat utf8Text.

Zwraca

SByte

Wynik analizowania utf8Text.

Implementuje

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parse(String, NumberStyles)

Źródło:

SByte.cs

Ważne

Ten interfejs API nie jest zgodny ze specyfikacją CLS.

Alternatywa zgodna ze specyfikacją CLS

System.Int16.Parse(String)

Konwertuje reprezentację ciągu liczby w określonym stylu na 8-bitową liczbę całkowitą ze znakiem 8-bitowym.

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

Ciąg zawierający liczbę do przekonwertowania. Ciąg jest interpretowany przy użyciu stylu określonego przez style.

style

NumberStyles

Bitowa kombinacja wartości wyliczenia wskazująca elementy stylu, które mogą być obecne w s. Typową wartością do określenia jest Integer.

Zwraca

SByte

Liczba całkowita ze znakiem 8-bitowym, która jest równoważna liczbie określonej w s.

Wyjątki

ArgumentNullException

s jest null.

FormatException

s nie jest w formacie zgodnym z style.

OverflowException

s reprezentuje liczbę mniejszą niż SByte.MinValue lub większą niż SByte.MaxValue.

-lub-

s zawiera cyfry niezerowe, ułamkowe.

ArgumentException

style nie jest wartością NumberStyles.

-lub-

style nie jest kombinacją wartości AllowHexSpecifier i HexNumber.

Przykłady

Poniższy przykład analizuje reprezentacje ciągów SByte wartości za pomocą metody Parse(String, NumberStyles). Bieżąca kultura przykładu to 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.

Uwagi

Parametr style definiuje elementy stylu (takie jak biały znak lub symbol znaku dodatniego lub ujemnego), które są dozwolone w parametrze s, aby operacja analizy zakończyła się pomyślnie. Musi to być kombinacja flag bitowych z wyliczenia NumberStyles.

W zależności od wartości styleparametr s może zawierać następujące elementy:

[ws] [$] [podpisywania] cyfry[.fractional_digits][E[podpisywania]exponential_digits][]

Jeśli style zawiera NumberStyles.AllowHexSpecifier, parametr s może zawierać następujące elementy:

[ws]hexdigits[ws]

Elementy w nawiasach kwadratowych ([ i ]) są opcjonalne. W poniższej tabeli opisano każdy element.

Pierwiastek	Opis
ws	Opcjonalne białe znaki. Białe znaki mogą pojawić się na początku s, jeśli style zawiera flagę NumberStyles.AllowLeadingWhite i może pojawić się na końcu s, jeśli styl zawiera flagę NumberStyles.AllowTrailingWhite.
$	Symbol waluty specyficznej dla kultury. Jego pozycja w ciągu jest definiowana przez właściwość NumberFormatInfo.CurrencyPositivePattern bieżącej kultury. Symbol waluty bieżącej kultury może pojawić się w s, jeśli style zawiera flagę NumberStyles.AllowCurrencySymbol.
podpisywania	Opcjonalny znak. Znak może pojawić się na początku s, jeśli style zawiera flagę NumberStyles.AllowLeadingSign i może pojawić się na końcu s, jeśli style zawiera flagę NumberStyles.AllowTrailingSign. Nawiasy mogą być używane w s, aby wskazać wartość ujemną, jeśli style zawiera flagę NumberStyles.AllowParentheses.
cyfry	Sekwencja cyfr z zakresu od 0 do 9.
.	Symbol separatora dziesiętnego specyficznego dla kultury. Symbol punktu dziesiętnego bieżącej kultury może pojawić się w s, jeśli style zawiera flagę NumberStyles.AllowDecimalPoint.
fractional_digits	Co najmniej jedno wystąpienie cyfry 0–9, jeśli style zawiera flagę NumberStyles.AllowExponent lub co najmniej jedno wystąpienie cyfry 0, jeśli nie. Cyfry ułamkowe mogą być wyświetlane w s tylko wtedy, gdy style zawiera flagę NumberStyles.AllowDecimalPoint.
E	Znak "e" lub "E", który wskazuje, że wartość jest reprezentowana w notacji wykładniczej (naukowej). Parametr s może reprezentować liczbę w notacji wykładniczej, jeśli style zawiera flagę NumberStyles.AllowExponent.
exponential_digits	Co najmniej jedno wystąpienie cyfry 0–9. Parametr s może reprezentować liczbę w notacji wykładniczej, jeśli style zawiera flagę NumberStyles.AllowExponent.
szesnastkowy	Sekwencja cyfr szesnastkowa od 0 do f lub od 0 do F.

Nuta

Wszystkie znaki NUL (U+0000) w s są ignorowane przez operację analizowania, niezależnie od wartości argumentu style.

Ciąg z cyframi dziesiętnymi (który odpowiada stylowi NumberStyles.None) zawsze jest analizowanych pomyślnie. Większość pozostałych elementów członkowskich NumberStyles, które mogą być obecne, ale nie muszą być obecne, w ciągu wejściowym. W poniższej tabeli przedstawiono, jak poszczególne elementy członkowskie NumberStyles wpływają na elementy, które mogą znajdować się w s.

Nieskładne wartości NumberStyles	Elementy dozwolone w oprócz cyfr
NumberStyles.None	Tylko cyfry dziesiętne.
NumberStyles.AllowDecimalPoint	Punkt dziesiętny (.) i elementy fractional_digits. Jeśli jednak style nie zawiera flagi NumberStyles.AllowExponent, fractional_digits musi zawierać tylko jedną lub więcej cyfr; w przeciwnym razie jest zgłaszany OverflowException.
NumberStyles.AllowExponent	Znak "e" lub "E", który wskazuje notację wykładniczą wraz z exponential_digits.
NumberStyles.AllowLeadingWhite	Element ws na początku s.
NumberStyles.AllowTrailingWhite	Element ws na końcu s.
NumberStyles.AllowLeadingSign	Znak dodatni przed cyframi.
NumberStyles.AllowTrailingSign	Znak dodatni po cyfrach.
NumberStyles.AllowParentheses	Znak element w postaci nawiasów otaczających wartość liczbową.
NumberStyles.AllowThousands	Element separatora grup (,). Chociaż separator grupy może być wyświetlany w s, musi być poprzedzony tylko jedną lub więcej cyfr.
NumberStyles.AllowCurrencySymbol	Element currency ($).

Jeśli jest używana flaga NumberStyles.AllowHexSpecifier, s musi być wartością szesnastkową. Prawidłowe cyfry szesnastkowe to 0–9, a-f i A-F. Prefiks taki jak "0x" nie jest obsługiwany i powoduje niepowodzenie operacji analizowania. Jedynymi innymi flagami, które można połączyć w style, są NumberStyles.AllowLeadingWhite i NumberStyles.AllowTrailingWhite. (Wyliczenie NumberStyles zawiera styl liczb złożonych, NumberStyles.HexNumber, który zawiera obie flagi odstępu).

Nuta

Jeśli parametr s jest reprezentacją ciągu liczby szesnastkowej, nie może być poprzedzony żadną dekoracją (taką jak 0x lub &h), która odróżnia ją jako liczbę szesnastkową. Powoduje to, że operacja analizy zgłasza wyjątek.

Jeśli s reprezentuje liczbę szesnastkową, metoda Parse(String, NumberStyles) interpretuje bit o wysokiej kolejności bajtu jako bit znaku.

Parametr s jest analizowany przy użyciu informacji o formatowaniu w obiekcie NumberFormatInfo zainicjowanym dla bieżącej kultury systemu. Aby użyć informacji o formatowaniu innej kultury, wywołaj przeciążenie Parse(String, NumberStyles, IFormatProvider).

Zobacz też

• ToString()
• TryParse
• analizowanie ciągów liczbowych na platformie .NET
• typy formatowania na platformie .NET