SByte.Parse Metode

Definisi

Ruang nama:

System

Rakitan:

System.Runtime.dll

Mengonversi representasi string dari angka ke bilangan bulat bertanda tangan 8-bit yang setara.

Overload

Parse(String, NumberStyles, IFormatProvider)	Mengonversi representasi string dari angka yang berada dalam gaya tertentu dan format khusus budaya ke setara dengan yang ditandatangani 8-bit.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Mengonversi representasi rentang angka yang berada dalam gaya tertentu dan format khusus budaya ke setara dengan yang ditandatangani 8-bit.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Mengurai rentang karakter UTF-8 menjadi nilai.
Parse(String, IFormatProvider)	Mengonversi representasi string dari angka dalam format khusus budaya tertentu ke bilangan bulat bertanda tangan 8-bit yang setara.
Parse(String)	Mengonversi representasi string dari angka ke bilangan bulat bertanda tangan 8-bit yang setara.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Mengurai rentang karakter menjadi nilai.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Mengurai rentang karakter UTF-8 menjadi nilai.
Parse(String, NumberStyles)	Mengonversi representasi string dari angka dalam gaya tertentu ke bilangan bulat bertanda tangan 8-bit yang setara.

Parse(String, NumberStyles, IFormatProvider)

Sumber:

SByte.cs

Penting

API ini bukan kompatibel CLS.

Alternatif kompatibel CLS

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

Mengonversi representasi string dari angka yang berada dalam gaya tertentu dan format khusus budaya ke setara dengan yang ditandatangani 8-bit.

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

Parameter

s

String

String yang berisi angka yang akan dikonversi. String ditafsirkan dengan menggunakan gaya yang ditentukan oleh style.

style

NumberStyles

Kombinasi bitwise dari nilai enumerasi yang menunjukkan elemen gaya yang dapat ada di s. Nilai umum yang akan ditentukan adalah Integer.

provider

IFormatProvider

Objek yang memasok informasi pemformatan khusus budaya tentang s. Jika providernull, budaya utas saat ini digunakan.

Mengembalikan

SByte

Nilai byte bertanda tangan 8-bit yang setara dengan angka yang ditentukan dalam parameter s.

Penerapan

Parse(String, NumberStyles, IFormatProvider)

Pengecualian

ArgumentException

style bukan nilai NumberStyles.

-atau-

style bukan kombinasi AllowHexSpecifier dan HexNumber.

ArgumentNullException

s null.

FormatException

s tidak dalam format yang sesuai dengan style.

OverflowException

mewakili angka yang kurang dari SByte.MinValue atau lebih besar dariSByte.MaxValue .

-atau-

s menyertakan digit pecahan non-nol.

Contoh

Contoh berikut mengilustrasikan penggunaan metode Parse(String, NumberStyles, IFormatProvider) untuk mengonversi berbagai representasi string angka menjadi nilai bilangan bulat yang ditandatangani.

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

Keterangan

Parameter style menentukan elemen gaya (seperti spasi kosong atau simbol tanda positif atau negatif) yang diizinkan dalam parameter s agar operasi penguraian berhasil. Ini harus merupakan kombinasi bendera bit dari enumerasi NumberStyles.

Bergantung pada nilai style, parameter s dapat mencakup elemen berikut:

[ws] [$] []digit[.fractional_digits][E[sign]exponential_digits][ws]

Jika style menyertakan AllowHexSpecifier, parameter s dapat menyertakan elemen berikut:

[ws]hexdigits[ws]

Elemen dalam tanda kurung siku ([ dan ]) bersifat opsional. Tabel berikut ini menjelaskan setiap elemen.

Elemen	Deskripsi
ws	Spasi kosong opsional. Spasi putih dapat muncul di awal s jika style menyertakan bendera NumberStyles.AllowLeadingWhite, dan dapat muncul di akhir s jika style menyertakan bendera NumberStyles.AllowTrailingWhite.
$	Simbol mata uang khusus budaya. Posisinya dalam string didefinisikan oleh properti NumberFormatInfo.CurrencyPositivePattern dari budaya saat ini. Simbol mata uang budaya saat ini dapat muncul di s jika style menyertakan bendera NumberStyles.AllowCurrencySymbol.
tanda tangan	Tanda opsional. Tanda dapat muncul di awal s jika style menyertakan bendera NumberStyles.AllowLeadingSign, dan tanda tersebut dapat muncul di akhir s jika style menyertakan bendera NumberStyles.AllowTrailingSign. Tanda kurung dapat digunakan dalam s untuk menunjukkan nilai negatif jika style menyertakan bendera NumberStyles.AllowParentheses.
digit	Urutan digit dari 0 hingga 9.
.	Simbol titik desimal khusus budaya. Simbol titik desimal budaya saat ini dapat muncul di s jika style menyertakan bendera NumberStyles.AllowDecimalPoint.
fractional_digits	Satu atau beberapa kemunculan digit 0-9 jika style menyertakan bendera NumberStyles.AllowExponent, atau satu atau beberapa kemunculan digit 0 jika tidak. Digit pecahan dapat muncul di s hanya jika style menyertakan bendera NumberStyles.AllowDecimalPoint.
E	Karakter "e" atau "E", yang menunjukkan bahwa nilai diwakili dalam notasi eksponensial (ilmiah). Parameter s dapat mewakili angka dalam notasi eksponensial jika style menyertakan bendera NumberStyles.AllowExponent.
exponential_digits	Urutan digit dari 0 hingga 9. Parameter s dapat mewakili angka dalam notasi eksponensial jika style menyertakan bendera NumberStyles.AllowExponent.
hexdigits	Urutan digit heksadesimal dari 0 hingga f, atau 0 hingga F.

Nota

Karakter NUL (U+0000) yang mengakhiri di s diabaikan oleh operasi penguraian, terlepas dari nilai argumen style.

String dengan digit desimal saja (yang sesuai dengan gaya NumberStyles.None) selalu berhasil diurai. Sebagian besar elemen kontrol anggota NumberStyles yang tersisa yang mungkin ada, tetapi tidak diharuskan ada, dalam string input ini. Tabel berikut menunjukkan bagaimana anggota NumberStyles individu memengaruhi elemen yang mungkin ada di s.

Nilai NumberStyles non-komposit	Elemen yang diizinkan dalam s selain digit
NumberStyles.None	Digit desimal saja.
NumberStyles.AllowDecimalPoint	Titik desimal (.) dan elemen fractional_digits. Namun, jika gaya tidak menyertakan bendera NumberStyles.AllowExponent, fractional_digits hanya boleh terdiri dari satu atau lebih 0 digit; jika tidak, OverflowException dilemparkan.
NumberStyles.AllowExponent	Karakter "e" atau "E", yang menunjukkan notasi eksponensial, bersama dengan exponential_digits.
NumberStyles.AllowLeadingWhite	Elemen ws di awal s.
NumberStyles.AllowTrailingWhite	Elemen ws di akhir .
NumberStyles.AllowLeadingSign	Tanda positif sebelum digit.
NumberStyles.AllowTrailingSign	Tanda positif setelah digit.
NumberStyles.AllowParentheses	Tanda kurung sebelum dan sesudah digit untuk menunjukkan nilai negatif.
NumberStyles.AllowThousands	Elemen pemisah grup (,). Meskipun pemisah grup dapat muncul di s, itu harus didahului oleh hanya satu atau lebih 0 digit.
NumberStyles.AllowCurrencySymbol	Elemen mata uang ($).

Jika bendera NumberStyles.AllowHexSpecifier digunakan, s harus berupa nilai heksadesimal. Digit heksadesimal yang valid adalah 0-9, a-f, dan A-F. Satu-satunya bendera lain yang dapat dikombinasikan dengannya adalah NumberStyles.AllowLeadingWhite dan NumberStyles.AllowTrailingWhite. (Enumerasi NumberStyles mencakup gaya angka komposit, NumberStyles.HexNumber, yang mencakup kedua bendera spasi putih.)

Nota

Jika parameter s adalah representasi string dari angka heksadesimal, parameter tersebut tidak dapat didahului oleh dekorasi apa pun (seperti 0x atau &h) yang membedakannya sebagai angka heksadesimal. Hal ini menyebabkan operasi penguraian melemparkan pengecualian.

Jika s mewakili angka heksadesimal, metode Parse(String, NumberStyles) menginterpretasikan bit byte urutan tinggi sebagai bit tanda.

Parameter provider adalah implementasi IFormatProvider yang metode GetFormat-nya mengembalikan objek NumberFormatInfo yang menyediakan informasi khusus budaya tentang format s. Ada tiga cara untuk menggunakan parameter provider untuk menyediakan informasi pemformatan kustom ke operasi penguraian:

• Anda dapat meneruskan objek NumberFormatInfo aktual yang menyediakan informasi pemformatan. (Implementasi GetFormat hanya mengembalikan dirinya sendiri.)

• Anda dapat meneruskan objek CultureInfo yang menentukan budaya yang pemformatannya akan digunakan. Properti NumberFormat menyediakan informasi pemformatan.

• Anda dapat meneruskan implementasi IFormatProvider kustom. Metode GetFormat harus membuat instans dan mengembalikan objek NumberFormatInfo yang menyediakan informasi pemformatan.

Jika providernull, objek NumberFormatInfo untuk budaya saat ini digunakan.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Sumber:

SByte.cs

Penting

API ini bukan kompatibel CLS.

Mengonversi representasi rentang angka yang berada dalam gaya tertentu dan format khusus budaya ke setara dengan yang ditandatangani 8-bit.

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

Parameter

s

ReadOnlySpan<Char>

Rentang yang berisi karakter yang mewakili angka yang akan dikonversi. Rentang ditafsirkan dengan menggunakan gaya yang ditentukan oleh style.

style

NumberStyles

Kombinasi bitwise dari nilai enumerasi yang menunjukkan elemen gaya yang dapat ada di s. Nilai umum yang akan ditentukan adalah Integer.

provider

IFormatProvider

Objek yang memasok informasi pemformatan khusus budaya tentang s. Jika providernull, budaya utas saat ini digunakan.

Mengembalikan

SByte

Nilai byte bertanda tangan 8-bit yang setara dengan angka yang ditentukan dalam parameter s.

Penerapan

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Sumber:

SByte.cs

Mengurai rentang karakter UTF-8 menjadi nilai.

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

Parameter

utf8Text

ReadOnlySpan<Byte>

Rentang karakter UTF-8 untuk diurai.

style

NumberStyles

Kombinasi bitwise dari gaya angka yang dapat ada di utf8Text.

provider

IFormatProvider

Objek yang menyediakan informasi pemformatan khusus budaya tentang utf8Text.

Mengembalikan

SByte

Hasil penguraian utf8Text.

Penerapan

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parse(String, IFormatProvider)

Sumber:

SByte.cs

Penting

API ini bukan kompatibel CLS.

Alternatif kompatibel CLS

System.Int16.Parse(String)

Mengonversi representasi string dari angka dalam format khusus budaya tertentu ke bilangan bulat bertanda tangan 8-bit yang setara.

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

Parameter

s

String

String yang mewakili angka yang akan dikonversi. String ditafsirkan menggunakan gaya Integer.

provider

IFormatProvider

Objek yang memasok informasi pemformatan khusus budaya tentang s. Jika providernull, budaya utas saat ini digunakan.

Mengembalikan

SByte

Bilangan bulat bertanda tangan 8-bit yang setara dengan angka yang ditentukan dalam s.

Penerapan

Parse(String, IFormatProvider)

Pengecualian

ArgumentNullException

s null.

FormatException

s tidak dalam format yang benar.

OverflowException

s mewakili angka yang kurang dari SByte.MinValue atau lebih besar dari SByte.MaxValue.

Contoh

Contoh berikut mendefinisikan objek NumberFormatInfo kustom yang menentukan tilde (~) sebagai tanda negatif. Kemudian mengurai sejumlah string numerik menggunakan objek NumberFormatInfo kustom ini serta objek CultureInfo yang mewakili budaya invarian.

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

Keterangan

Parameter s berisi sejumlah formulir:

[ws] [tanda]digit[ws]

Elemen dalam tanda kurung siku ([ dan ]) bersifat opsional. Tabel berikut ini menjelaskan setiap elemen.

Elemen	Deskripsi
ws	Spasi kosong opsional.
tanda tangan	Tanda opsional.
digit	Urutan digit mulai dari 0 hingga 9.

Parameter s ditafsirkan menggunakan gaya Integer. Selain digit desimal nilai byte, hanya spasi di depan dan belakang dengan tanda di depan yang diizinkan. Untuk secara eksplisit menentukan elemen gaya dengan informasi pemformatan khusus budaya yang dapat ada di s, gunakan metode Parse(String, NumberStyles, IFormatProvider).

Parameter provider adalah implementasi IFormatProvider yang metode GetFormat-nya mengembalikan objek NumberFormatInfo yang menyediakan informasi khusus budaya tentang format s. Ada tiga cara untuk menggunakan parameter provider untuk menyediakan informasi pemformatan kustom ke operasi penguraian:

• Anda dapat meneruskan objek NumberFormatInfo aktual yang menyediakan informasi pemformatan. (Implementasi GetFormat hanya mengembalikan dirinya sendiri.)

• Anda dapat meneruskan objek CultureInfo yang menentukan budaya yang pemformatannya akan digunakan. Properti NumberFormat menyediakan informasi pemformatan.

• Anda dapat meneruskan implementasi IFormatProvider kustom. Metode GetFormat harus membuat instans dan mengembalikan objek NumberFormatInfo yang menyediakan informasi pemformatan.

Jika providernull, objek NumberFormatInfo untuk budaya saat ini digunakan.

Lihat juga

• ToString()
• TryParse
• Mengurai String Numerik di .NET

Parse(String)

Sumber:

SByte.cs

Penting

API ini bukan kompatibel CLS.

Alternatif kompatibel CLS

System.Int16.Parse(String)

Mengonversi representasi string dari angka ke bilangan bulat bertanda tangan 8-bit yang setara.

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

Parameter

s

String

String yang mewakili angka yang akan dikonversi. String ditafsirkan menggunakan gaya Integer.

Mengembalikan

SByte

Bilangan bulat bertanda tangan 8-bit yang setara dengan angka yang terkandung dalam parameter s.

Pengecualian

ArgumentException

s null.

FormatException

s tidak terdiri dari tanda opsional diikuti dengan urutan digit (nol hingga sembilan).

OverflowException

s mewakili angka yang kurang dari SByte.MinValue atau lebih besar dari SByte.MaxValue.

Contoh

Contoh berikut menunjukkan cara mengonversi nilai string menjadi nilai byte yang ditandatangani menggunakan metode Parse. Nilai byte yang ditandatangani yang dihasilkan kemudian ditampilkan ke konsol.

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

Keterangan

Parameter s berisi sejumlah formulir:

[ws] [tanda]digit[ws]

Elemen dalam tanda kurung siku ([ dan ]) bersifat opsional. Tabel berikut ini menjelaskan setiap elemen.

Elemen	Deskripsi
ws	Spasi kosong opsional.
tanda tangan	Tanda opsional.
digit	Urutan digit mulai dari 0 hingga 9.

Parameter s ditafsirkan menggunakan gaya NumberStyles.Integer. Selain digit desimal nilai byte, hanya spasi di depan dan belakang dengan tanda positif atau negatif terkemuka yang diizinkan. Untuk secara eksplisit menentukan elemen gaya yang dapat ada di s, gunakan metode Parse(String, NumberStyles) atau Parse(String, NumberStyles, IFormatProvider).

Parameter s diurai dengan menggunakan informasi pemformatan dalam NumberFormatInfo yang diinisialisasi untuk budaya sistem saat ini. Untuk informasi selengkapnya, lihat NumberFormatInfo.CurrentInfo. Untuk mengurai string dengan menggunakan informasi pemformatan dari beberapa budaya lain, gunakan metode Parse(String, NumberStyles, IFormatProvider).

Lihat juga

• Mengurai String Numerik di .NET
• Tipe Pemformatan di .NET

Parse(ReadOnlySpan<Char>, IFormatProvider)

Sumber:

SByte.cs

Mengurai rentang karakter menjadi nilai.

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

Parameter

s

ReadOnlySpan<Char>

Rentang karakter untuk diurai.

provider

IFormatProvider

Objek yang menyediakan informasi pemformatan khusus budaya tentang s.

Mengembalikan

SByte

Hasil penguraian s.

Penerapan

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Sumber:

SByte.cs

Mengurai rentang karakter UTF-8 menjadi nilai.

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

Parameter

utf8Text

ReadOnlySpan<Byte>

Rentang karakter UTF-8 untuk diurai.

provider

IFormatProvider

Objek yang menyediakan informasi pemformatan khusus budaya tentang utf8Text.

Mengembalikan

SByte

Hasil penguraian utf8Text.

Penerapan

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parse(String, NumberStyles)

Sumber:

SByte.cs

Penting

API ini bukan kompatibel CLS.

Alternatif kompatibel CLS

System.Int16.Parse(String)

Mengonversi representasi string dari angka dalam gaya tertentu ke bilangan bulat bertanda tangan 8-bit yang setara.

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

Parameter

s

String

String yang berisi angka yang akan dikonversi. String ditafsirkan menggunakan gaya yang ditentukan oleh style.

style

NumberStyles

Kombinasi bitwise dari nilai enumerasi yang menunjukkan elemen gaya yang dapat ada di s. Nilai umum yang akan ditentukan adalah Integer.

Mengembalikan

SByte

Bilangan bulat bertanda tangan 8-bit yang setara dengan angka yang ditentukan dalam s.

Pengecualian

ArgumentNullException

s null.

FormatException

s tidak dalam format yang sesuai dengan style.

OverflowException

s mewakili angka yang kurang dari SByte.MinValue atau lebih besar dari SByte.MaxValue.

-atau-

s menyertakan digit pecahan non-nol.

ArgumentException

style bukan nilai NumberStyles.

-atau-

style bukan kombinasi nilai AllowHexSpecifier dan HexNumber.

Contoh

Contoh berikut mengurai representasi string dari nilai SByte dengan metode Parse(String, NumberStyles). Budaya saat ini untuk contohnya adalah 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.

Keterangan

Parameter style menentukan elemen gaya (seperti spasi kosong atau simbol tanda positif atau negatif) yang diizinkan dalam parameter s agar operasi penguraian berhasil. Ini harus merupakan kombinasi bendera bit dari enumerasi NumberStyles.

Bergantung pada nilai style, parameter s dapat mencakup elemen berikut:

[ws] [$] []digit[.fractional_digits][E[sign]exponential_digits][ws]

Jika style menyertakan NumberStyles.AllowHexSpecifier, parameter s mungkin berisi elemen berikut:

[ws]hexdigits[ws]

Elemen dalam tanda kurung siku ([ dan ]) bersifat opsional. Tabel berikut ini menjelaskan setiap elemen.

Elemen	Deskripsi
ws	Spasi kosong opsional. Spasi kosong dapat muncul di awal s jika style menyertakan bendera NumberStyles.AllowLeadingWhite, dan dapat muncul di akhir s jika gaya menyertakan bendera NumberStyles.AllowTrailingWhite.
$	Simbol mata uang khusus budaya. Posisinya dalam string didefinisikan oleh properti NumberFormatInfo.CurrencyPositivePattern dari budaya saat ini. Simbol mata uang budaya saat ini dapat muncul di s jika style menyertakan bendera NumberStyles.AllowCurrencySymbol.
tanda tangan	Tanda opsional. Tanda dapat muncul di awal s jika style menyertakan bendera NumberStyles.AllowLeadingSign, dan dapat muncul di akhir s jika style menyertakan bendera NumberStyles.AllowTrailingSign. Tanda kurung dapat digunakan dalam s untuk menunjukkan nilai negatif jika style menyertakan bendera NumberStyles.AllowParentheses.
digit	Urutan digit dari 0 hingga 9.
.	Simbol titik desimal khusus budaya. Simbol titik desimal budaya saat ini dapat muncul di s jika style menyertakan bendera NumberStyles.AllowDecimalPoint.
fractional_digits	Satu atau beberapa kemunculan digit 0-9 jika style menyertakan bendera NumberStyles.AllowExponent, atau satu atau beberapa kemunculan digit 0 jika tidak. Digit pecahan dapat muncul di s hanya jika style menyertakan bendera NumberStyles.AllowDecimalPoint.
E	Karakter "e" atau "E", yang menunjukkan bahwa nilai diwakili dalam notasi eksponensial (ilmiah). Parameter s dapat mewakili angka dalam notasi eksponensial jika style menyertakan bendera NumberStyles.AllowExponent.
exponential_digits	Satu atau beberapa kemunculan digit 0-9. Parameter s dapat mewakili angka dalam notasi eksponensial jika style menyertakan bendera NumberStyles.AllowExponent.
hexdigits	Urutan digit heksadesimal dari 0 hingga f, atau 0 hingga F.

Nota

Karakter NUL (U+0000) yang mengakhiri di s diabaikan oleh operasi penguraian, terlepas dari nilai argumen style.

String dengan digit desimal saja (yang sesuai dengan gaya NumberStyles.None) selalu berhasil diurai. Sebagian besar elemen kontrol anggota NumberStyles yang tersisa yang mungkin ada, tetapi tidak diharuskan ada, dalam string input. Tabel berikut menunjukkan bagaimana anggota NumberStyles individu memengaruhi elemen yang mungkin ada di s.

Nilai NumberStyles non-komposit	Elemen yang diizinkan dalam selain digit
NumberStyles.None	Digit desimal saja.
NumberStyles.AllowDecimalPoint	Titik desimal (.) dan elemen fractional_digits. Namun, jika style tidak menyertakan bendera NumberStyles.AllowExponent, fractional_digits hanya boleh terdiri dari satu atau lebih 0 digit; jika tidak, OverflowException dilemparkan.
NumberStyles.AllowExponent	Karakter "e" atau "E", yang menunjukkan notasi eksponensial, bersama dengan exponential_digits.
NumberStyles.AllowLeadingWhite	Elemen ws di awal s.
NumberStyles.AllowTrailingWhite	Elemen ws di akhir .
NumberStyles.AllowLeadingSign	Tanda positif sebelum digit.
NumberStyles.AllowTrailingSign	Tanda positif setelah digit.
NumberStyles.AllowParentheses	Elemen tanda dalam bentuk tanda kurung yang mencakup nilai numerik.
NumberStyles.AllowThousands	Elemen pemisah grup (,). Meskipun pemisah grup dapat muncul di s, itu harus didahului oleh hanya satu atau lebih 0 digit.
NumberStyles.AllowCurrencySymbol	Elemen mata uang ($).

Jika bendera NumberStyles.AllowHexSpecifier digunakan, s harus berupa nilai heksadesimal. Digit heksadesimal yang valid adalah 0-9, a-f, dan A-F. Awalan seperti "0x" tidak didukung dan menyebabkan operasi penguraian gagal. Satu-satunya bendera lain yang dapat digabungkan termasuk dalam style adalah NumberStyles.AllowLeadingWhite dan NumberStyles.AllowTrailingWhite. (Enumerasi NumberStyles mencakup gaya angka komposit, NumberStyles.HexNumber, yang mencakup kedua bendera spasi putih.)

Nota

Jika parameter s adalah representasi string dari angka heksadesimal, parameter tersebut tidak dapat didahului oleh dekorasi apa pun (seperti 0x atau &h) yang membedakannya sebagai angka heksadesimal. Hal ini menyebabkan operasi penguraian melemparkan pengecualian.

Jika s mewakili angka heksadesimal, metode Parse(String, NumberStyles) menginterpretasikan bit byte urutan tinggi sebagai bit tanda.

Parameter s diurai dengan menggunakan informasi pemformatan dalam objek NumberFormatInfo yang diinisialisasi untuk budaya sistem saat ini. Untuk menggunakan informasi pemformatan beberapa budaya lain, panggil Parse(String, NumberStyles, IFormatProvider) kelebihan beban.

Lihat juga

• ToString()
• TryParse
• Mengurai String Numerik di .NET
• Tipe Pemformatan di .NET