SByte.Parse Metod

Definition

Namnområde:: System

Sammansättningar:: mscorlib.dll, System.Runtime.dll

Sammansättningar:: netstandard.dll, System.Runtime.dll

Sammansättning:: System.Runtime.dll

Sammansättning:: mscorlib.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Konverterar strängrepresentationen av ett tal till dess 8-bitars signerade heltalsekvivalent.

Överlagringar

Name	Description
Parse(String)	Konverterar strängrepresentationen av ett tal till dess 8-bitars signerade heltalsekvivalent.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Parsar ett intervall med UTF-8 tecken till ett värde.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsar ett teckenintervall till ett värde.
Parse(String, NumberStyles)	Konverterar strängrepresentationen av ett tal i ett angivet format till dess 8-bitars signerade heltalsmotsvarighet.
Parse(String, IFormatProvider)	Konverterar strängrepresentationen av ett tal i ett angivet kulturspecifikt format till dess 8-bitars signerade heltalsekvivalent.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Parsar ett intervall med UTF-8 tecken till ett värde.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konverterar spanrepresentationen av ett tal som har ett angivet format och ett kulturspecifikt format till dess 8-bitars signerade motsvarighet.
Parse(String, NumberStyles, IFormatProvider)	Konverterar strängrepresentationen av ett tal som har ett angivet format och ett kulturspecifikt format till dess 8-bitars signerade motsvarighet.

Parse(String)

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Viktigt!

Detta API uppfyller inte CLS.

Alternativ som uppfyller CLS: System.Int16.Parse(String)

Konverterar strängrepresentationen av ett tal till dess 8-bitars signerade heltalsekvivalent.

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

Parametrar

s: String

En sträng som representerar ett tal som ska konverteras. Strängen tolkas med formatet Integer .

Returer

SByte

Ett 8-bitars signerat heltal som motsvarar talet i parametern s .

Attribut: CLSCompliantAttribute

Undantag

ArgumentException

s är null.

FormatException

s består inte av ett valfritt tecken följt av en sekvens med siffror (noll till nio).

OverflowException

s representerar ett tal som är mindre än SByte.MinValue eller större än SByte.MaxValue.

Exempel

I följande exempel visas hur du konverterar ett strängvärde till ett signerat bytevärde med hjälp av Parse metoden . Det resulterande signerade bytevärdet visas sedan för konsolen.

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

Kommentarer

Parametern s innehåller ett antal av formuläret:

[ws][sign]digits[ws]

Element inom hakparenteser ([ och ]) är valfria. I följande tabell beskrivs varje element.

Element	Description
Ws	Valfritt blanksteg.
signera	Ett valfritt tecken.
Siffror	En sekvens med siffror mellan 0 och 9.

Parametern s tolkas med formatet NumberStyles.Integer . Förutom bytevärdets decimalsiffror tillåts endast inledande och avslutande blanksteg med ett inledande positivt eller negativt tecken. Om du uttryckligen vill definiera de formatelement som kan finnas i sanvänder du antingen Parse(String, NumberStyles) metoden eller Parse(String, NumberStyles, IFormatProvider) .

Parametern s parsas med hjälp av formateringsinformationen i en NumberFormatInfo som initieras för den aktuella systemkulturen. Mer information finns i NumberFormatInfo.CurrentInfo. Använd metoden för att parsa en sträng med hjälp av formateringsinformationen Parse(String, NumberStyles, IFormatProvider) för någon annan kultur.

Se även

Gäller för

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Parsar ett intervall med UTF-8 tecken till ett värde.

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

Parametrar

utf8Text: ReadOnlySpan<Byte>

Intervallet för UTF-8 tecken att parsa.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om utf8Text.

Returer

SByte

Resultatet av parsning utf8Text.

Implementeringar

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Gäller för

Parse(ReadOnlySpan<Char>, IFormatProvider)

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Parsar ett teckenintervall till ett värde.

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

Parametrar

s: ReadOnlySpan<Char>

Det intervall med tecken som ska parsas.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om s.

Returer

SByte

Resultatet av parsning s.

Implementeringar

Parse(ReadOnlySpan<Char>, IFormatProvider)

Gäller för

Parse(String, NumberStyles)

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Viktigt!

Detta API uppfyller inte CLS.

Alternativ som uppfyller CLS: System.Int16.Parse(String)

Konverterar strängrepresentationen av ett tal i ett angivet format till dess 8-bitars signerade heltalsmotsvarighet.

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

Parametrar

s: String

En sträng som innehåller ett tal som ska konverteras. Strängen tolkas med det format som anges av style.

style: NumberStyles

En bitvis kombination av uppräkningsvärdena som anger de formatelement som kan finnas i s. Ett typiskt värde att ange är Integer.

Returer

SByte

Ett 8-bitars signerat heltal som motsvarar det tal som anges i s.

Attribut: CLSCompliantAttribute

Undantag

ArgumentNullException

s är null.

FormatException

s är inte i ett format som är kompatibelt med style.

OverflowException

s representerar ett tal som är mindre än SByte.MinValue eller större än SByte.MaxValue.

-eller-

s innehåller icke-noll, bråktalssiffror.

ArgumentException

style är inte ett NumberStyles värde.

-eller-

style är inte en kombination av AllowHexSpecifier och HexNumber värden.

Exempel

I följande exempel parsas strängrepresentationer av SByte värden med Parse(String, NumberStyles) -metoden. Den aktuella kulturen för exemplet är 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.

Kommentarer

Parametern style definierar formatelementen (till exempel blanksteg eller symbolen för positiva eller negativa tecken) som tillåts i parametern s för att parsningsåtgärden ska lyckas. Det måste vara en kombination av bitflaggor från NumberStyles uppräkningen.

Beroende på värdet för stylekan parametern s innehålla följande element:

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

Om style innehåller NumberStyles.AllowHexSpecifierkan parametern s innehålla följande element:

[ws]hexdigits[ws]

Element inom hakparenteser ([ och ]) är valfria. I följande tabell beskrivs varje element.

Element	Description
Ws	Valfritt blanksteg. Tomt utrymme kan visas i början av `s` om `style` innehåller NumberStyles.AllowLeadingWhite flaggan, och det kan visas i slutet av `s` om formatmallen NumberStyles.AllowTrailingWhite innehåller flaggan.
$	En kulturspecifik valutasymbol. Dess position i strängen definieras av egenskapen NumberFormatInfo.CurrencyPositivePattern för den aktuella kulturen. Den aktuella kulturens valutasymbol kan visas i `s` om `style` den NumberStyles.AllowCurrencySymbol innehåller flaggan.
signera	Ett valfritt tecken. Tecknet kan visas i början av `s` om `style` innehåller NumberStyles.AllowLeadingSign flaggan, och det kan visas i slutet av `s` om `style` innehåller NumberStyles.AllowTrailingSign flaggan. Parenteser kan användas i `s` för att ange ett negativt värde om `style` den NumberStyles.AllowParentheses innehåller flaggan.
Siffror	En sekvens med siffror från 0 till 9.
.	Ett kulturspecifikt decimaltecken. Den aktuella kulturens decimaltecken kan visas i `s` om `style` den NumberStyles.AllowDecimalPoint innehåller flaggan.
fractional_digits	En eller flera förekomster av siffran 0–9 om `style` den NumberStyles.AllowExponent innehåller flaggan, eller en eller flera förekomster av siffran 0 om den inte gör det. Bråksiffror kan bara visas i `s` om `style` den NumberStyles.AllowDecimalPoint innehåller flaggan.
E	Tecknet "e" eller "E", som anger att värdet representeras i exponentiell (vetenskaplig) notation. Parametern `s` kan representera ett tal i exponentiell notation om `style` den NumberStyles.AllowExponent innehåller flaggan.
exponential_digits	En eller flera förekomster av siffran 0–9. Parametern `s` kan representera ett tal i exponentiell notation om `style` den NumberStyles.AllowExponent innehåller flaggan.
hexdigits	En sekvens med hexadecimala siffror från 0 till f eller 0 till och med F.

Note

Alla avslutande NUL-tecken (U+0000) i s ignoreras av parsningsåtgärden, oavsett argumentets style värde.

En sträng med endast decimalsiffror (vilket motsvarar NumberStyles.None formatet) parsar alltid korrekt. De flesta av de återstående NumberStyles medlemmarna styr element som kan finnas, men som inte krävs för att finnas, i indatasträngen. Följande tabell visar hur enskilda NumberStyles medlemmar påverkar de element som kan finnas i s.

Icke-sammansatta NumberStyles-värden	Element som tillåts i s utöver siffror
NumberStyles.None	Endast decimalsiffror.
NumberStyles.AllowDecimalPoint	Decimaltecknet (.) och fractional_digits element. Om `style` flaggan inte ingår NumberStyles.AllowExponent måste fractional_digits dock bara bestå av en eller flera 0 siffror. Annars utlöses en OverflowException .
NumberStyles.AllowExponent	Tecknet "e" eller "E", som anger exponentiell notation, tillsammans med exponential_digits.
NumberStyles.AllowLeadingWhite	WS-elementet i början av `s`.
NumberStyles.AllowTrailingWhite	WS-elementet i slutet av `s`.
NumberStyles.AllowLeadingSign	Ett positivt tecken före siffror.
NumberStyles.AllowTrailingSign	Ett positivt tecken efter siffror.
NumberStyles.AllowParentheses	Teckenelementet i form av parenteser som omger det numeriska värdet.
NumberStyles.AllowThousands	Gruppavgränsaren (,). Även om gruppavgränsaren kan visas i `s`måste den föregås av endast en eller flera 0 siffror.
NumberStyles.AllowCurrencySymbol	Valutaelementet ($).

NumberStyles.AllowHexSpecifier Om flaggan används s måste vara ett hexadecimalt värde. Giltiga hexadecimala siffror är 0–9, a-f och A-F. Ett prefix som "0x" stöds inte och gör att parsningsåtgärden misslyckas. De enda andra flaggorna som kan kombineras i style är NumberStyles.AllowLeadingWhite och NumberStyles.AllowTrailingWhite. (Uppräkningen NumberStyles innehåller ett sammansatt talformat, NumberStyles.HexNumber, som innehåller båda blankstegsflaggor.)

Note

Om parametern s är strängrepresentationen av ett hexadecimalt tal kan den inte föregås av någon dekoration (till exempel 0x eller &h) som särskiljer den som ett hexadecimalt tal. Detta gör att parsningsåtgärden utlöser ett undantag.

Om s representerar ett hexadecimalt tal Parse(String, NumberStyles) tolkar metoden högordningsbiten av bytet som en teckenbit.

Parametern s parsas med hjälp av formateringsinformationen i ett NumberFormatInfo objekt som initieras för den aktuella systemkulturen. Om du vill använda formateringsinformationen för någon annan kultur anropar du överlagringen Parse(String, NumberStyles, IFormatProvider) .

Se även

Gäller för

Parse(String, IFormatProvider)

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Viktigt!

Detta API uppfyller inte CLS.

Alternativ som uppfyller CLS: System.Int16.Parse(String)

Konverterar strängrepresentationen av ett tal i ett angivet kulturspecifikt format till dess 8-bitars signerade heltalsekvivalent.

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

Parametrar

s: String

En sträng som representerar ett tal som ska konverteras. Strängen tolkas med formatet Integer .

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om s. Om provider är nullanvänds den aktuella trådkulturen.

Returer

SByte

Ett 8-bitars signerat heltal som motsvarar det tal som anges i s.

Implementeringar

Parse(String, IFormatProvider)

Attribut: CLSCompliantAttribute

Undantag

ArgumentNullException

s är null.

FormatException

s är inte i rätt format.

OverflowException

s representerar ett tal som är mindre än SByte.MinValue eller större än SByte.MaxValue.

Exempel

I följande exempel definieras ett anpassat NumberFormatInfo objekt som definierar tilde (~) som det negativa tecknet. Sedan parsar den ett antal numeriska strängar med det här anpassade NumberFormatInfo objektet samt ett CultureInfo objekt som representerar den invarianta kulturen.

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

Kommentarer

Parametern s innehåller ett antal av formuläret:

[ws][sign]digits[ws]

Element inom hakparenteser ([ och ]) är valfria. I följande tabell beskrivs varje element.

Element	Description
Ws	Valfritt blanksteg.
signera	Ett valfritt tecken.
Siffror	En sekvens med siffror mellan 0 och 9.

Parametern s tolkas med formatet Integer . Förutom bytevärdets decimalsiffror tillåts endast inledande och avslutande blanksteg med ett inledande tecken. Om du uttryckligen vill definiera formatelementen med den kulturspecifika formateringsinformation som kan finnas i sanvänder du Parse(String, NumberStyles, IFormatProvider) metoden .

Parametern provider är en IFormatProvider implementering vars GetFormat metod returnerar ett NumberFormatInfo objekt som tillhandahåller kulturspecifik information om formatet för s. Det finns tre sätt att använda parametern provider för att ange anpassad formateringsinformation till parsningsåtgärden:

Du kan skicka det faktiska NumberFormatInfo objektet som innehåller formateringsinformation. (Dess implementering av GetFormat returnerar helt enkelt sig själv.)
Du kan skicka ett CultureInfo objekt som anger den kultur vars formatering ska användas. Dess NumberFormat egenskap innehåller formateringsinformation.
Du kan genomföra en anpassad IFormatProvider implementering. Dess GetFormat metod måste instansiera och returnera det NumberFormatInfo objekt som tillhandahåller formateringsinformation.

Om provider är nullNumberFormatInfo används objektet för den aktuella kulturen.

Se även

Gäller för

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Parsar ett intervall med UTF-8 tecken till ett värde.

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

Parametrar

utf8Text: ReadOnlySpan<Byte>

Intervallet för UTF-8 tecken att parsa.

style: NumberStyles

En bitvis kombination av talformat som kan finnas i utf8Text.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om utf8Text.

Returer

SByte

Resultatet av parsning utf8Text.

Implementeringar

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Gäller för

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Viktigt!

Detta API uppfyller inte CLS.

Konverterar spanrepresentationen av ett tal som har ett angivet format och ett kulturspecifikt format till dess 8-bitars signerade motsvarighet.

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

Parametrar

s: ReadOnlySpan<Char>

Ett intervall som innehåller de tecken som representerar talet som ska konverteras. Intervallet tolkas med hjälp av formatet som anges av style.

style: NumberStyles

En bitvis kombination av uppräkningsvärdena som anger de formatelement som kan finnas i s. Ett typiskt värde att ange är Integer.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om s. Om provider är nullanvänds den aktuella trådkulturen.

Returer

SByte

Ett 8-bitars signerat bytevärde som motsvarar det tal som anges i parametern s .

Implementeringar

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Attribut: CLSCompliantAttribute

Gäller för

Parse(String, NumberStyles, IFormatProvider)

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Källa:: SByte.cs

Viktigt!

Detta API uppfyller inte CLS.

Alternativ som uppfyller CLS: System.Int16.Parse(String, NumberStyles, IFormatProvider)

Konverterar strängrepresentationen av ett tal som har ett angivet format och ett kulturspecifikt format till dess 8-bitars signerade motsvarighet.

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

Parametrar

s: String

En sträng som innehåller talet som ska konverteras. Strängen tolkas med hjälp av formatet som anges av style.

style: NumberStyles

En bitvis kombination av uppräkningsvärdena som anger de formatelement som kan finnas i s. Ett typiskt värde att ange är Integer.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om s. Om provider är nullanvänds den aktuella trådkulturen.

Returer

SByte

Ett 8-bitars signerat bytevärde som motsvarar det tal som anges i parametern s .

Implementeringar

Parse(String, NumberStyles, IFormatProvider)

Attribut: CLSCompliantAttribute

Undantag

ArgumentException

style är inte ett NumberStyles värde.

-eller-

style är inte en kombination av AllowHexSpecifier och HexNumber.

ArgumentNullException

s är null.

FormatException

s är inte i ett format som är kompatibelt med style.

OverflowException

s representerar ett tal som är mindre än SByte.MinValue eller större än SByte.MaxValue.

-eller-

s innehåller icke-noll, bråktalssiffror.

Exempel

I följande exempel visas hur metoden används Parse(String, NumberStyles, IFormatProvider) för att konvertera olika strängrepresentationer av tal till signerade heltalsvärden.

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

Kommentarer

Beroende på värdet för stylekan parametern s innehålla följande element:

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

Om style innehåller AllowHexSpecifierkan parametern s innehålla följande element:

[ws]hexdigits[ws]

Element inom hakparenteser ([ och ]) är valfria. I följande tabell beskrivs varje element.

Element	Description
Ws	Valfritt blanksteg. Tomt utrymme kan visas i början av `s` om `style` innehåller NumberStyles.AllowLeadingWhite flaggan, och det kan visas i slutet av `s` om `style` innehåller NumberStyles.AllowTrailingWhite flaggan.
$	En kulturspecifik valutasymbol. Dess position i strängen definieras av egenskapen NumberFormatInfo.CurrencyPositivePattern för den aktuella kulturen. Den aktuella kulturens valutasymbol kan visas i `s` om `style` den NumberStyles.AllowCurrencySymbol innehåller flaggan.
signera	Ett valfritt tecken. Tecknet kan visas i början av `s` om `style` innehåller NumberStyles.AllowLeadingSign flaggan, och det kan visas i slutet av `s` om `style` innehåller NumberStyles.AllowTrailingSign flaggan. Parenteser kan användas i `s` för att ange ett negativt värde om `style` den NumberStyles.AllowParentheses innehåller flaggan.
Siffror	En sekvens med siffror från 0 till 9.
.	Ett kulturspecifikt decimaltecken. Den aktuella kulturens decimaltecken kan visas i `s` om `style` den NumberStyles.AllowDecimalPoint innehåller flaggan.
fractional_digits	En eller flera förekomster av siffran 0–9 om `style` den NumberStyles.AllowExponent innehåller flaggan, eller en eller flera förekomster av siffran 0 om den inte gör det. Bråksiffror kan bara visas i `s` om `style` den NumberStyles.AllowDecimalPoint innehåller flaggan.
E	Tecknet "e" eller "E", som anger att värdet representeras i exponentiell (vetenskaplig) notation. Parametern `s` kan representera ett tal i exponentiell notation om `style` den NumberStyles.AllowExponent innehåller flaggan.
exponential_digits	En sekvens med siffror från 0 till 9. Parametern `s` kan representera ett tal i exponentiell notation om `style` den NumberStyles.AllowExponent innehåller flaggan.
hexdigits	En sekvens med hexadecimala siffror från 0 till f eller 0 till och med F.

Note

Alla avslutande NUL-tecken (U+0000) i s ignoreras av parsningsåtgärden, oavsett argumentets style värde.

En sträng med endast decimalsiffror (vilket motsvarar NumberStyles.None formatet) parsar alltid korrekt. De flesta av de återstående NumberStyles medlemmarna styr element som kan finnas, men som inte måste finnas i den här indatasträngen. Följande tabell visar hur enskilda NumberStyles medlemmar påverkar de element som kan finnas i s.

Icke-sammansatta `NumberStyles` värden	Element som tillåts `s` utöver siffror
NumberStyles.None	Endast decimalsiffror.
NumberStyles.AllowDecimalPoint	Decimaltecknet (.) och fractional_digits element. Men om formatmallen NumberStyles.AllowExponent inte innehåller flaggan måste fractional_digits endast bestå av en eller flera 0 siffror. Annars genereras en OverflowException .
NumberStyles.AllowExponent	Tecknet "e" eller "E", som anger exponentiell notation, tillsammans med exponential_digits.
NumberStyles.AllowLeadingWhite	WS-elementet i början av `s`.
NumberStyles.AllowTrailingWhite	WS-elementet i slutet av `s`.
NumberStyles.AllowLeadingSign	Ett positivt tecken före siffror.
NumberStyles.AllowTrailingSign	Ett positivt tecken efter siffror.
NumberStyles.AllowParentheses	Parenteser före och efter siffror för att indikera ett negativt värde.
NumberStyles.AllowThousands	Gruppavgränsaren (,). Även om gruppavgränsaren kan visas i `s`måste den föregås av endast en eller flera 0 siffror.
NumberStyles.AllowCurrencySymbol	Valutaelementet ($).

NumberStyles.AllowHexSpecifier Om flaggan används s måste vara ett hexadecimalt värde. Giltiga hexadecimala siffror är 0–9, a-f och A-F. De enda andra flaggorna som kan kombineras med den är NumberStyles.AllowLeadingWhite och NumberStyles.AllowTrailingWhite. (Uppräkningen NumberStyles innehåller ett sammansatt talformat, NumberStyles.HexNumber, som innehåller båda blankstegsflaggor.)

Note

Om s representerar ett hexadecimalt tal Parse(String, NumberStyles) tolkar metoden högordningsbiten av bytet som en teckenbit.

Du kan skicka det faktiska NumberFormatInfo objektet som innehåller formateringsinformation. (Dess implementering av GetFormat returnerar helt enkelt sig själv.)
Du kan skicka ett CultureInfo objekt som anger den kultur vars formatering ska användas. Dess NumberFormat egenskap innehåller formateringsinformation.
Du kan genomföra en anpassad IFormatProvider implementering. Dess GetFormat metod måste instansiera och returnera det NumberFormatInfo objekt som tillhandahåller formateringsinformation.

Om provider är nullNumberFormatInfo används objektet för den aktuella kulturen.

Gäller för

Feedback

Var den här sidan till hjälp?