SByte.Parse Methode

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

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

Parameters

Retouren

Een 8-bits geheel getal dat gelijk is aan het getal in de s parameter.

Kenmerken

CLSCompliantAttribute

Uitzonderingen

Voorbeelden

In het volgende voorbeeld ziet u hoe u een tekenreekswaarde converteert naar een ondertekende bytewaarde met behulp van de Parse methode. De resulterende ondertekende bytewaarde wordt vervolgens weergegeven in de console.

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

Opmerkingen

De s parameter bevat een getal van het formulier:

[ws][teken]digits[ws]

Elementen in vierkante haken ([ en ]) zijn optioneel. In de volgende tabel wordt elk element beschreven.

Element	Beschrijving
Ws	Optionele witruimte.
ondertekenen	Een optioneel teken.
Cijfers	Een reeks cijfers tussen 0 en 9.

De s parameter wordt geïnterpreteerd met behulp van de NumberStyles.Integer stijl. Naast de decimale cijfers van de bytewaarde zijn alleen voorloop- en volgspaties met een voorloop-positief of negatief teken toegestaan. Als u expliciet de stijlelementen wilt definiëren waarin u aanwezig kunt zijn s, gebruikt u de Parse(String, NumberStyles) of de Parse(String, NumberStyles, IFormatProvider) methode.

De s parameter wordt geparseerd met behulp van de opmaakgegevens in een NumberFormatInfo die is geïnitialiseerd voor de huidige systeemcultuur. Zie NumberFormatInfo.CurrentInfo voor meer informatie. Als u een tekenreeks wilt parseren met behulp van de opmaakgegevens van een andere cultuur, gebruikt u de Parse(String, NumberStyles, IFormatProvider) methode.

Zie ook

• Parsing Numerieke tekenreeksen in .NET
• Opmaaktypen in .NET

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

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

Parameters

Retouren

Het resultaat van parseren utf8Text.

Implementeringen

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

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

Parameters

Retouren

Het resultaat van parseren s.

Implementeringen

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

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

Parameters

Retouren

Een 8-bits geheel getal dat gelijk is aan het getal dat is opgegeven in s.

Kenmerken

CLSCompliantAttribute

Uitzonderingen

Voorbeelden

In het volgende voorbeeld worden tekenreeksweergaven van SByte waarden geparseerd met de Parse(String, NumberStyles) methode. De huidige cultuur voor het voorbeeld is 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.

Opmerkingen

De style parameter definieert de stijlelementen (zoals witruimte of het positieve of negatieve tekensymbool) die zijn toegestaan in de s parameter om de parseringsbewerking te laten slagen. Dit moet een combinatie zijn van bitvlagmen uit de NumberStyles opsomming.

Afhankelijk van de waarde van style, kan de s parameter de volgende elementen bevatten:

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

Indien style opgenomen NumberStyles.AllowHexSpecifier, kan de s parameter de volgende elementen bevatten:

[ws]hexdigits[ws]

Elementen in vierkante haken ([ en ]) zijn optioneel. In de volgende tabel wordt elk element beschreven.

Element	Beschrijving
Ws	Optionele witruimte. Witruimte kan aan het begin van s de styleNumberStyles.AllowLeadingWhite vlag worden weergegeven en kan worden weergegeven aan het einde van s als de stijl de NumberStyles.AllowTrailingWhite vlag bevat.
$	Een cultuurspecifiek valutasymbool. De positie in de tekenreeks wordt gedefinieerd door de NumberFormatInfo.CurrencyPositivePattern eigenschap van de huidige cultuur. Het valutasymbool van de huidige cultuur kan worden weergegeven als sstyle deze de NumberStyles.AllowCurrencySymbol vlag bevat.
ondertekenen	Een optioneel teken. Het teken kan aan het begin van s de styleNumberStyles.AllowLeadingSign vlag worden weergegeven en kan aan het einde van s de vlag worden weergegeven.styleNumberStyles.AllowTrailingSign Haakjes kunnen worden gebruikt s om een negatieve waarde aan te geven als style deze de NumberStyles.AllowParentheses vlag bevat.
Cijfers	Een reeks cijfers van 0 tot en met 9.
.	Een cultuurspecifiek decimaalteken. Het decimale puntsymbool van de huidige cultuur kan worden weergegeven s als style deze de NumberStyles.AllowDecimalPoint vlag bevat.
fractional_digits	Een of meer exemplaren van het cijfer 0-9 als style deze de NumberStyles.AllowExponent vlag bevat, of een of meer exemplaren van het cijfer 0 als dat niet het geval is. Fractionele cijfers kunnen alleen worden weergegeven als sstyle de NumberStyles.AllowDecimalPoint vlag wordt opgenomen.
E	Het teken "e" of "E", dat aangeeft dat de waarde wordt weergegeven in exponentiële (wetenschappelijke) notatie. De s parameter kan een getal in exponentiële notatie vertegenwoordigen als style deze de NumberStyles.AllowExponent vlag bevat.
exponential_digits	Een of meer exemplaren van het cijfer 0-9. De s parameter kan een getal in exponentiële notatie vertegenwoordigen als style deze de NumberStyles.AllowExponent vlag bevat.
hexdigits	Een reeks hexadecimale cijfers van 0 tot en met f of 0 tot en met F.

Een tekenreeks met alleen decimale cijfers (die overeenkomt met de NumberStyles.None stijl) wordt altijd geparseerd. De meeste resterende NumberStyles leden bepalen elementen die mogelijk aanwezig zijn, maar die niet aanwezig zijn, in de invoertekenreeks. De volgende tabel geeft aan hoe afzonderlijke NumberStyles leden van invloed zijn op de elementen die aanwezig kunnen zijn in s.

Niet-samengestelde getalstijlwaarden	Elementen die naast cijfers zijn toegestaan
NumberStyles.None	Alleen decimale cijfers.
NumberStyles.AllowDecimalPoint	De decimale punt (.) en fractional_digits elementen. Als style de NumberStyles.AllowExponent vlag echter niet is opgenomen, moet fractional_digits uit slechts één of meer 0 cijfers bestaan; anders wordt er een OverflowException gegenereerd.
NumberStyles.AllowExponent	Het teken "e" of "E", dat exponentiële notatie aangeeft, samen met exponential_digits.
NumberStyles.AllowLeadingWhite	Het ws-element aan het begin van s.
NumberStyles.AllowTrailingWhite	Het ws-element aan het einde van s.
NumberStyles.AllowLeadingSign	Een positief teken vóór cijfers.
NumberStyles.AllowTrailingSign	Een positief teken na cijfers.
NumberStyles.AllowParentheses	Het tekenelement in de vorm van haakjes tussen de numerieke waarde.
NumberStyles.AllowThousands	Het groepsscheidingsteken (,) element. Hoewel het groepsscheidingsteken kan worden weergegeven s, moet het worden voorafgegaan door slechts een of meer 0 cijfers.
NumberStyles.AllowCurrencySymbol	Het valutaelement ($).

Als de NumberStyles.AllowHexSpecifier vlag wordt gebruikt, s moet dit een hexadecimale waarde zijn. Geldige hexadecimale cijfers zijn 0-9, a-f en A-F. Een voorvoegsel zoals '0x' wordt niet ondersteund en zorgt ervoor dat de parseringsbewerking mislukt. De enige andere vlaggen die kunnen worden gecombineerd in style zijn NumberStyles.AllowLeadingWhite en NumberStyles.AllowTrailingWhite. (De NumberStyles opsomming bevat een samengestelde getalstijl, NumberStyles.HexNumberdie beide spatievlagmen bevat.)

Als s dit een hexadecimaal getal vertegenwoordigt, interpreteert de Parse(String, NumberStyles) methode de bit van hoge volgorde van de byte als een tekenbit.

De s parameter wordt geparseerd met behulp van de opmaakgegevens in een NumberFormatInfo object dat is geïnitialiseerd voor de huidige systeemcultuur. Als u de opmaakgegevens van een andere cultuur wilt gebruiken, roept u de Parse(String, NumberStyles, IFormatProvider) overbelasting aan.

Zie ook

• ToString()
• TryParse
• Parsing Numerieke tekenreeksen in .NET
• Opmaaktypen in .NET

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

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

Parameters

Retouren

Een 8-bits geheel getal dat gelijk is aan het getal dat is opgegeven in s.

Implementeringen

Kenmerken

CLSCompliantAttribute

Uitzonderingen

Voorbeelden

In het volgende voorbeeld wordt een aangepast NumberFormatInfo object gedefinieerd dat de tilde (~) definieert als het negatieve teken. Vervolgens wordt een aantal numerieke tekenreeksen geparseerd met behulp van dit aangepaste NumberFormatInfo object, evenals een CultureInfo object dat de invariante cultuur vertegenwoordigt.

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

Opmerkingen

De s parameter bevat een getal van het formulier:

[ws][teken]digits[ws]

Elementen in vierkante haken ([ en ]) zijn optioneel. In de volgende tabel wordt elk element beschreven.

Element	Beschrijving
Ws	Optionele witruimte.
ondertekenen	Een optioneel teken.
Cijfers	Een reeks cijfers tussen 0 en 9.

De s parameter wordt geïnterpreteerd met behulp van de Integer stijl. Naast de decimale cijfers van de bytewaarde zijn alleen voorloop- en volgspaties met een voorloopteken toegestaan. Als u de stijlelementen expliciet wilt definiëren met de cultuurspecifieke opmaakinformatie die aanwezig kan zijn s, gebruikt u de Parse(String, NumberStyles, IFormatProvider) methode.

De provider parameter is een IFormatProvider implementatie waarvan de GetFormat methode een NumberFormatInfo object retourneert dat cultuurspecifieke informatie biedt over de indeling van s. Er zijn drie manieren om de provider parameter te gebruiken om aangepaste opmaakgegevens op te geven voor de parseringsbewerking:

• U kunt het werkelijke NumberFormatInfo object doorgeven dat opmaakinformatie biedt. (De implementatie van GetFormat simpelweg retourneert zichzelf.)

• U kunt een CultureInfo object doorgeven dat de cultuur aangeeft waarvan de opmaak moet worden gebruikt. De NumberFormat eigenschap bevat opmaakgegevens.

• U kunt een aangepaste IFormatProvider implementatie doorgeven. De GetFormat methode moet het object instantiëren en retourneren NumberFormatInfo dat opmaakinformatie biedt.

Als provider dat het is null, wordt het NumberFormatInfo object voor de huidige cultuur gebruikt.

Zie ook

• ToString()
• TryParse
• Parsing Numerieke tekenreeksen in .NET

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

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

Parameters

Retouren

Het resultaat van parseren utf8Text.

Implementeringen

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

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

Parameters

Retouren

Een 8-bits ondertekende bytewaarde die gelijk is aan het getal dat is opgegeven in de s parameter.

Implementeringen

Kenmerken

CLSCompliantAttribute

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

Bron:

SByte.cs

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

Parameters

Retouren

Een 8-bits ondertekende bytewaarde die gelijk is aan het getal dat is opgegeven in de s parameter.

Implementeringen

Kenmerken

CLSCompliantAttribute

Uitzonderingen

Voorbeelden

In het volgende voorbeeld ziet u het gebruik van de Parse(String, NumberStyles, IFormatProvider) methode om verschillende tekenreeksweergaven van getallen te converteren naar ondertekende gehele getallen.

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

Opmerkingen

De style parameter definieert de stijlelementen (zoals witruimte of het positieve of negatieve tekensymbool) die zijn toegestaan in de s parameter om de parseringsbewerking te laten slagen. Dit moet een combinatie zijn van bitvlagmen uit de NumberStyles opsomming.

Afhankelijk van de waarde van style, kan de s parameter de volgende elementen bevatten:

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

Als style dit is opgenomen AllowHexSpecifier, kan de s parameter de volgende elementen bevatten:

[ws]hexdigits[ws]

Elementen in vierkante haken ([ en ]) zijn optioneel. In de volgende tabel wordt elk element beschreven.

Element	Beschrijving
Ws	Optionele witruimte. Witruimte kan aan het begin van s de styleNumberStyles.AllowLeadingWhite vlag worden weergegeven en deze kan aan het einde van s de styleNumberStyles.AllowTrailingWhite vlag worden weergegeven.
$	Een cultuurspecifiek valutasymbool. De positie in de tekenreeks wordt gedefinieerd door de NumberFormatInfo.CurrencyPositivePattern eigenschap van de huidige cultuur. Het valutasymbool van de huidige cultuur kan worden weergegeven als sstyle deze de NumberStyles.AllowCurrencySymbol vlag bevat.
ondertekenen	Een optioneel teken. Het teken kan aan het begin van s de vlag worden weergegeven, styleNumberStyles.AllowLeadingSign en het kan het einde van s de vlag weergeven als style deze de NumberStyles.AllowTrailingSign vlag bevat. Haakjes kunnen worden gebruikt s om een negatieve waarde aan te geven als style deze de NumberStyles.AllowParentheses vlag bevat.
Cijfers	Een reeks cijfers van 0 tot en met 9.
.	Een cultuurspecifiek decimaalteken. Het decimale puntsymbool van de huidige cultuur kan worden weergegeven s als style deze de NumberStyles.AllowDecimalPoint vlag bevat.
fractional_digits	Een of meer exemplaren van het cijfer 0-9 als style deze de NumberStyles.AllowExponent vlag bevat, of een of meer exemplaren van het cijfer 0 als dat niet het geval is. Fractionele cijfers kunnen alleen worden weergegeven als sstyle de NumberStyles.AllowDecimalPoint vlag wordt opgenomen.
E	Het teken "e" of "E", dat aangeeft dat de waarde wordt weergegeven in exponentiële (wetenschappelijke) notatie. De s parameter kan een getal in exponentiële notatie vertegenwoordigen als style deze de NumberStyles.AllowExponent vlag bevat.
exponential_digits	Een reeks cijfers van 0 tot en met 9. De s parameter kan een getal in exponentiële notatie vertegenwoordigen als style deze de NumberStyles.AllowExponent vlag bevat.
hexdigits	Een reeks hexadecimale cijfers van 0 tot en met f of 0 tot en met F.

Een tekenreeks met alleen decimale cijfers (die overeenkomt met de NumberStyles.None stijl) wordt altijd geparseerd. De meeste resterende NumberStyles leden bepalen elementen die mogelijk aanwezig zijn, maar die niet aanwezig zijn, in deze invoertekenreeks. De volgende tabel geeft aan hoe afzonderlijke NumberStyles leden van invloed zijn op de elementen die aanwezig kunnen zijn in s.

Niet-samengestelde NumberStyles waarden	Elementen die naast cijfers zijn toegestaan s
NumberStyles.None	Alleen decimale cijfers.
NumberStyles.AllowDecimalPoint	De decimale punt (.) en fractional_digits elementen. Als de stijl echter niet de NumberStyles.AllowExponent vlag bevat, moet fractional_digits uit slechts één of meer cijfers bestaan; anders wordt er een OverflowException gegenereerd.
NumberStyles.AllowExponent	Het teken "e" of "E", dat exponentiële notatie aangeeft, samen met exponential_digits.
NumberStyles.AllowLeadingWhite	Het ws-element aan het begin van s.
NumberStyles.AllowTrailingWhite	Het ws-element aan het einde van s.
NumberStyles.AllowLeadingSign	Een positief teken vóór cijfers.
NumberStyles.AllowTrailingSign	Een positief teken na cijfers.
NumberStyles.AllowParentheses	Haakjes voor en na cijfers om een negatieve waarde aan te geven.
NumberStyles.AllowThousands	Het groepsscheidingsteken (,) element. Hoewel het groepsscheidingsteken kan worden weergegeven s, moet het worden voorafgegaan door slechts een of meer 0 cijfers.
NumberStyles.AllowCurrencySymbol	Het valutaelement ($).

Als de NumberStyles.AllowHexSpecifier vlag wordt gebruikt, s moet dit een hexadecimale waarde zijn. Geldige hexadecimale cijfers zijn 0-9, a-f en A-F. De enige andere vlaggen die ermee kunnen worden gecombineerd, zijn NumberStyles.AllowLeadingWhite en NumberStyles.AllowTrailingWhite. (De NumberStyles opsomming bevat een samengestelde getalstijl, NumberStyles.HexNumberdie beide spatievlagmen bevat.)

Als s dit een hexadecimaal getal vertegenwoordigt, interpreteert de Parse(String, NumberStyles) methode de bit van hoge volgorde van de byte als een tekenbit.

De provider parameter is een IFormatProvider implementatie waarvan de GetFormat methode een NumberFormatInfo object retourneert dat cultuurspecifieke informatie biedt over de indeling van s. Er zijn drie manieren om de provider parameter te gebruiken om aangepaste opmaakgegevens op te geven voor de parseringsbewerking:

• U kunt het werkelijke NumberFormatInfo object doorgeven dat opmaakinformatie biedt. (De implementatie van GetFormat simpelweg retourneert zichzelf.)

• U kunt een CultureInfo object doorgeven dat de cultuur aangeeft waarvan de opmaak moet worden gebruikt. De NumberFormat eigenschap bevat opmaakgegevens.

• U kunt een aangepaste IFormatProvider implementatie doorgeven. De GetFormat methode moet het object instantiëren en retourneren NumberFormatInfo dat opmaakinformatie biedt.

Als provider dat het is null, wordt het NumberFormatInfo object voor de huidige cultuur gebruikt.