Int16.Parse Methode

Definitie

Naamruimte:: System

Assembly's:: mscorlib.dll, System.Runtime.dll

Assembly's:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Converteert de tekenreeksweergave van een getal naar het equivalent van het 16-bits ondertekende gehele getal.

Overloads

Name	Description
Parse(String)	Converteert de tekenreeksweergave van een getal naar het equivalent van het 16-bits ondertekende gehele getal.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Parseert een reeks UTF-8 tekens in een waarde.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parseert een reeks tekens in een waarde.
Parse(String, NumberStyles)	Converteert de tekenreeksweergave van een getal in een opgegeven stijl naar het equivalent van het 16-bits ondertekende gehele getal.
Parse(String, IFormatProvider)	Converteert de tekenreeksweergave van een getal in een opgegeven cultuurspecifieke indeling naar het equivalent van het 16-bits ondertekende gehele getal.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Parseert een reeks UTF-8 tekens in een waarde.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Converteert de spanweergave van een getal in een opgegeven stijl en cultuurspecifieke notatie naar het equivalent van het 16-bits ondertekende gehele getal.
Parse(String, NumberStyles, IFormatProvider)	Converteert de tekenreeksweergave van een getal in een opgegeven stijl en cultuurspecifieke notatie naar het equivalent van het 16-bits ondertekende gehele getal.

Parse(String)

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Converteert de tekenreeksweergave van een getal naar het equivalent van het 16-bits ondertekende gehele getal.

public:
 static short Parse(System::String ^ s);

public static short Parse(string s);

static member Parse : string -> int16

Public Shared Function Parse (s As String) As Short

Parameters

s: String

Een tekenreeks die een getal bevat dat moet worden geconverteerd.

Retouren

Int16

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

Uitzonderingen

ArgumentNullException

s is null.

FormatException

s heeft niet de juiste indeling.

OverflowException

s vertegenwoordigt een getal kleiner dan Int16.MinValue of groter dan Int16.MaxValue.

Voorbeelden

In het volgende voorbeeld ziet u hoe u een tekenreekswaarde converteert naar een 16-bits geheel getal met behulp van de Int16.Parse(String) methode. De resulterende gehele waarde wordt vervolgens weergegeven in de console.

string value;
short number;

value = " 12603 ";
try
{
   number = Int16.Parse(value);
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
}
catch (FormatException)
{
   Console.WriteLine("Unable to convert '{0}' to a 16-bit signed integer.",
                     value);
}

value = " 16,054";
try
{
   number = Int16.Parse(value);
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
}
catch (FormatException)
{
   Console.WriteLine("Unable to convert '{0}' to a 16-bit signed integer.",
                     value);
}

value = " -17264";
try
{
   number = Int16.Parse(value);
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
}
catch (FormatException)
{
   Console.WriteLine("Unable to convert '{0}' to a 16-bit signed integer.",
                     value);
}
// The example displays the following output to the console:
//       Converted ' 12603 ' to 12603.
//       Unable to convert ' 16,054' to a 16-bit signed integer.
//       Converted ' -17264' to -17264.

let value = " 12603 "
try
    let number = Int16.Parse value
    printfn $"Converted '{value}' to {number}." 
with :? FormatException -> 
    printfn $"Unable to convert '{value}' to a 16-bit signed integer."

let value = " 16,054"
try
    let number = Int16.Parse value
    printfn $"Converted '{value}' to {number}."
with :? FormatException ->
    printfn "Unable to convert '{value}' to a 16-bit signed integer."
                    
let value = " -17264"
try
    let number = Int16.Parse value
    printfn $"Converted '{value}' to {number}."
with :? FormatException ->
    printfn "Unable to convert '{value}' to a 16-bit signed integer."
    

// The example displays the following output to the console:
//       Converted ' 12603 ' to 12603.
//       Unable to convert ' 16,054' to a 16-bit signed integer.
//       Converted ' -17264' to -17264.

Dim value As String
Dim number As Short

value = " 12603 "
Try
   number = Short.Parse(value)
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Catch e As FormatException
   Console.WriteLine("Unable to convert '{0}' to a 16-bit signed integer.", _
                     value)
End Try

value = " 16,054"
Try
   number = Short.Parse(value)
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Catch e As FormatException
   Console.WriteLine("Unable to convert '{0}' to a 16-bit signed integer.", _
                     value)
End Try
                        
value = " -17264"
Try
   number = Short.Parse(value)
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Catch e As FormatException
   Console.WriteLine("Unable to convert '{0}' to a 16-bit signed integer.", _
                     value)
End Try
' The example displays the following output to the console:
'       Converted ' 12603 ' to 12603.
'       Unable to convert ' 16,054' to a 16-bit signed integer.
'       Converted ' -17264' to -17264.

Opmerkingen

De s parameter bevat een getal van het formulier:

[ws][sign]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 gehele waarde zijn alleen voorloop- en volgspaties met een voorloopteken toegestaan. Als u expliciet de stijlelementen wilt definiëren waarin u aanwezig kunt zijn s, gebruikt u de Int16.Parse(String, NumberStyles) of de Parse methode.

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

Zie ook

Van toepassing op

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Parseert een reeks UTF-8 tekens in een waarde.

public:
 static short Parse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider) = IUtf8SpanParsable<short>::Parse;

public static short Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider);

static member Parse : ReadOnlySpan<byte> * IFormatProvider -> int16

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider) As Short

Parameters

utf8Text: ReadOnlySpan<Byte>

Het bereik van UTF-8 tekens om te parseren.

provider: IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie biedt over utf8Text.

Retouren

Int16

Het resultaat van parseren utf8Text.

Implementeringen

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Van toepassing op

Parse(ReadOnlySpan<Char>, IFormatProvider)

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Parseert een reeks tekens in een waarde.

public:
 static short Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<short>::Parse;

public static short Parse(ReadOnlySpan<char> s, IFormatProvider? provider);

static member Parse : ReadOnlySpan<char> * IFormatProvider -> int16

Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As Short

Parameters

s: ReadOnlySpan<Char>

De reeks tekens die moeten worden geparseerd.

provider: IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie biedt over s.

Retouren

Int16

Het resultaat van parseren s.

Implementeringen

Parse(ReadOnlySpan<Char>, IFormatProvider)

Van toepassing op

Parse(String, NumberStyles)

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Converteert de tekenreeksweergave van een getal in een opgegeven stijl naar het equivalent van het 16-bits ondertekende gehele getal.

public:
 static short Parse(System::String ^ s, System::Globalization::NumberStyles style);

public static short Parse(string s, System.Globalization.NumberStyles style);

static member Parse : string * System.Globalization.NumberStyles -> int16

Public Shared Function Parse (s As String, style As NumberStyles) As Short

Parameters

s: String

Een tekenreeks die een getal bevat dat moet worden geconverteerd.

style: NumberStyles

Een bitsgewijze combinatie van de opsommingswaarden die de stijlelementen aangeeft die aanwezig kunnen zijn in s. Een typische waarde die moet worden opgegeven, is Integer.

Retouren

Int16

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

Uitzonderingen

ArgumentNullException

s is null.

ArgumentException

style is geen NumberStyles waarde.

– of –

style is geen combinatie van AllowHexSpecifier en HexNumber waarden.

FormatException

s heeft geen indeling die compatibel is met style.

OverflowException

s vertegenwoordigt een getal kleiner dan Int16.MinValue of groter dan Int16.MaxValue.

– of –

s bevat niet-nul fractionele cijfers.

Voorbeelden

In het volgende voorbeeld wordt de Int16.Parse(String, NumberStyles) methode gebruikt om de tekenreeksweergaven van waarden te parseren met behulp van Int16 de en-US cultuur.

using System;
using System.Globalization;

public class ParseSample
{
   public static void Main()
   {
      string value;
      NumberStyles style;

      // Parse a number with a thousands separator (throws an exception).
      value = "14,644";
      style = NumberStyles.None;
      ParseToInt16(value, style);

      style = NumberStyles.AllowThousands;
      ParseToInt16(value, style);

      // Parse a number with a thousands separator and decimal point.
      value = "14,644.00";
      style = NumberStyles.AllowThousands | NumberStyles.Integer |
              NumberStyles.AllowDecimalPoint;
      ParseToInt16(value, style);

      // Parse a number with a fractional component (throws an exception).
      value = "14,644.001";
      ParseToInt16(value, style);

      // Parse a number in exponential notation.
      value = "145E02";
      style = style | NumberStyles.AllowExponent;
      ParseToInt16(value, style);

      // Parse a number in exponential notation with a positive sign.
      value = "145E+02";
      ParseToInt16(value, style);

      // Parse a number in exponential notation with a negative sign
      // (throws an exception).
      value = "145E-02";
      ParseToInt16(value, style);
   }

   private static void ParseToInt16(string value, NumberStyles style)
   {
      try
      {
         short number = Int16.Parse(value, style);
         Console.WriteLine("Converted '{0}' to {1}.", value, number);
      }
      catch (FormatException)
      {
         Console.WriteLine("Unable to parse '{0}' with style {1}.", value,
                           style.ToString());
      }
      catch (OverflowException)
      {
         Console.WriteLine("'{0}' is out of range of the Int16 type.", value);
      }
   }
}
// The example displays the following output to the console:
//       Unable to parse '14,644' with style None.
//       Converted '14,644' to 14644.
//       Converted '14,644.00' to 14644.
//       '14,644.001' is out of range of the Int16 type.
//       Converted '145E02' to 14500.
//       Converted '145E+02' to 14500.
//       '145E-02' is out of range of the Int16 type.

open System
open System.Globalization

let parseToInt16 (value: string) (style: NumberStyles) =
    try
        let number = Int16.Parse(value, style)
        printfn $"Converted '{value}' to {number}."
    with
    | :? FormatException ->
        printfn $"Unable to parse '{value}' with style {style}."
    | :? OverflowException ->
        printfn $"'{value}' is out of range of the Int16 type."

[<EntryPoint>]
let main _ =
    // Parse a number with a thousands separator (throws an exception).
    let value = "14,644"
    let style = NumberStyles.None
    parseToInt16 value style

    let style = NumberStyles.AllowThousands
    parseToInt16 value style

    // Parse a number with a thousands separator and decimal point.
    let value = "14,644.00"
    let style = NumberStyles.AllowThousands ||| NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint
    parseToInt16 value style

    // Parse a number with a fractional component (throws an exception).
    let value = "14,644.001"
    parseToInt16 value style

    // Parse a number in exponential notation.
    let value = "145E02"
    let style = style ||| NumberStyles.AllowExponent
    parseToInt16 value style

    // Parse a number in exponential notation with a positive sign.
    let value = "145E+02"
    parseToInt16 value style

    // Parse a number in exponential notation with a negative sign
    // (throws an exception).
    let value = "145E-02"
    parseToInt16 value style

    0

// The example displays the following output to the console:
//       Unable to parse '14,644' with style None.
//       Converted '14,644' to 14644.
//       Converted '14,644.00' to 14644.
//       '14,644.001' is out of range of the Int16 type.
//       Converted '145E02' to 14500.
//       Converted '145E+02' to 14500.
//       '145E-02' is out of range of the Int16 type.

Imports System.Globalization

Module ParseSample
   Public Sub Main()
      Dim value As String 
      Dim style As NumberStyles
      
      ' Parse a number with a thousands separator (throws an exception).
      value = "14,644"
      style = NumberStyles.None
      ParseToInt16(value, style)
      
      style = NumberStyles.AllowThousands
      ParseToInt16(value, style)
      
      ' Parse a number with a thousands separator and decimal point.
      value = "14,644.00"
      style = NumberStyles.AllowThousands Or NumberStyles.Integer Or _
              NumberStyles.AllowDecimalPoint
      ParseToInt16(value, style)
      
      ' Parse a number with a fractional component (throws an exception).
      value = "14,644.001"
      ParseToInt16(value, style)
      
      ' Parse a number in exponential notation.
      value = "145E02"
      style = style Or NumberStyles.AllowExponent
      ParseToInt16(value, style)
      
      ' Parse a number in exponential notation with a positive sign.
      value = "145E+02"
      ParseToInt16(value, style)
      
      ' Parse a number in exponential notation with a negative sign
      ' (throws an exception).
      value = "145E-02"
      ParseToInt16(value, style)
   End Sub
   
   Private Sub ParseToInt16(value As String, style As NumberStyles)
      Try
         Dim number As Short = Int16.Parse(value, style)
         Console.WriteLine("Converted '{0}' to {1}.", value, number)
      Catch e As FormatException
         Console.WriteLine("Unable to parse '{0}' with style {1}.", value, _
                           style.ToString())
      Catch e As OverflowException
         Console.WriteLine("'{0}' is out of range of the Int16 type.", value)
      End Try
   End Sub   
End Module
' The example displays the following output to the console:
'       Unable to parse '14,644' with style None.
'       Converted '14,644' to 14644.
'       Converted '14,644.00' to 14644.
'       '14,644.001' is out of range of the Int16 type.
'       Converted '145E02' to 14500.
'       Converted '145E+02' to 14500.
'       '145E-02' is out of range of the Int16 type.

Opmerkingen

De style parameter definieert de stijlelementen (zoals witruimte of een 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][$][teken][cijfers;]digits[.fractional_digits][e[sign]digits][ws]

Of, indien style opgenomen AllowHexSpecifier:

[ws]hexdigits[ws]

Items 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 `style`NumberStyles.AllowLeadingWhite vlag worden weergegeven, of aan het einde van `s` de `style`NumberStyles.AllowTrailingWhite vlag.
$	Een cultuurspecifiek valutasymbool. De positie in de tekenreeks wordt gedefinieerd door de NumberFormatInfo.CurrencyPositivePattern en NumberFormatInfo.CurrencyNegativePattern eigenschappen 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 `style`NumberStyles.AllowLeadingSign vlag worden weergegeven en kan aan het einde van `s` de vlag worden weergegeven.`style`NumberStyles.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 scheidingsteken voor duizendtallen. Het scheidingsteken voor duizendtallen van de huidige cultuur kan worden weergegeven als `sstyle` deze de NumberStyles.AllowThousands vlag bevat.
.	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 reeks van het 0 cijfer. Fractionele cijfers kunnen worden weergegeven als `sstyle` deze de NumberStyles.AllowDecimalPoint vlag bevat. Als een ander cijfer dan 0 wordt weergegeven in fractional_digits, genereert de methode een OverflowException.
e	Het teken e of E, dat aangeeft dat `s` kan worden weergegeven in exponentiële notatie. De `s` parameter kan een getal in exponentiële notatie vertegenwoordigen als `style` deze de NumberStyles.AllowExponent vlag bevat. De `s` parameter moet echter een getal vertegenwoordigen in het gegevensbereik van het Int16 gegevenstype en mag geen niet-nul fractioneel onderdeel hebben.
hexdigits	Een reeks hexadecimale cijfers van 0 tot en met f of 0 tot en met F.

Note

Alle nultekens (U+0000) s worden genegeerd door de parseringsbewerking, ongeacht de waarde van het style argument.

Een tekenreeks met alleen cijfers (die overeenkomt met de NumberStyles.None stijl) parseert altijd succesvol. De meeste resterende NumberStyles leden bepalen elementen die mogelijk wel aanwezig zijn in deze invoertekenreeks, maar die niet aanwezig zijn. 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 elementen . en fractional_digits . Fractional_digits mag echter bestaan uit slechts één of meer cijfers of een OverflowException wordt gegenereerd.
NumberStyles.AllowExponent	De `s` parameter kan ook exponentiële notatie gebruiken.
NumberStyles.AllowLeadingWhite	Het ws-element aan het begin van `s`.
NumberStyles.AllowTrailingWhite	Het ws-element aan het einde van `s`.
NumberStyles.AllowLeadingSign	Een teken kan vóór cijfers worden weergegeven.
NumberStyles.AllowTrailingSign	Een teken kan na cijfers worden weergegeven.
NumberStyles.AllowParentheses	Het tekenelement in de vorm van haakjes tussen de numerieke waarde.
NumberStyles.AllowThousands	Het , element.
NumberStyles.AllowCurrencySymbol	Het $ element.

Als de NumberStyles.AllowHexSpecifier vlag wordt gebruikt, s moet dit de tekenreeksweergave zijn van een hexadecimale waarde zonder voorvoegsel. '9AF3' parseert bijvoorbeeld met succes, maar '0x9AF3' niet. De enige andere vlaggen die aanwezig kunnen zijn, style zijn NumberStyles.AllowLeadingWhite en NumberStyles.AllowTrailingWhite. (De NumberStyles opsomming heeft een samengestelde getalstijl, NumberStyles.HexNumberdie beide witruimtevlagmen bevat.)

De s parameter wordt geparseerd met behulp van de opmaakgegevens in een NumberFormatInfo object dat is geïnitialiseerd voor de huidige systeemcultuur. Zie NumberFormatInfo.CurrentInfo voor meer informatie. Als u de opmaakgegevens van een specifieke cultuur wilt parseren s , roept u de Int16.Parse(String, NumberStyles, IFormatProvider) methode aan.

Zie ook

Van toepassing op

Parse(String, IFormatProvider)

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Converteert de tekenreeksweergave van een getal in een opgegeven cultuurspecifieke indeling naar het equivalent van het 16-bits ondertekende gehele getal.

public:
 static short Parse(System::String ^ s, IFormatProvider ^ provider);

public:
 static short Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<short>::Parse;

public static short Parse(string s, IFormatProvider provider);

public static short Parse(string s, IFormatProvider? provider);

static member Parse : string * IFormatProvider -> int16

Public Shared Function Parse (s As String, provider As IFormatProvider) As Short

Parameters

s: String

Een tekenreeks die een getal bevat dat moet worden geconverteerd.

provider: IFormatProvider

Een IFormatProvider die cultuurspecifieke opmaakinformatie over s.

Retouren

Int16

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

Implementeringen

Parse(String, IFormatProvider)

Uitzonderingen

ArgumentNullException

s is null.

FormatException

s heeft niet de juiste indeling.

OverflowException

s vertegenwoordigt een getal kleiner dan Int16.MinValue of groter dan Int16.MaxValue.

Voorbeelden

In het volgende voorbeeld worden tekenreeksweergaven van Int16 waarden geparseerd met de Int16.Parse(String, IFormatProvider) methode.

string stringToConvert;
short number;

stringToConvert = " 214 ";
try
{
   number = Int16.Parse(stringToConvert, CultureInfo.InvariantCulture);
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, number);
}
catch (FormatException)
{
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert);
}
catch (OverflowException)
{
   Console.WriteLine("'{0'} is out of range of the Int16 data type.",
                     stringToConvert);
}

stringToConvert = " + 214";
try
{
   number = Int16.Parse(stringToConvert, CultureInfo.InvariantCulture);
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, number);
}
catch (FormatException)
{
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert);
}
catch (OverflowException)
{
   Console.WriteLine("'{0'} is out of range of the Int16 data type.",
                     stringToConvert);
}

stringToConvert = " +214 ";
try
{
   number = Int16.Parse(stringToConvert, CultureInfo.InvariantCulture);
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, number);
}
catch (FormatException)
{
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert);
}
catch (OverflowException)
{
   Console.WriteLine("'{0'} is out of range of the Int16 data type.",
                     stringToConvert);
}
// The example displays the following output to the console:
//       Converted ' 214 ' to 214.
//       Unable to parse ' + 214'.
//       Converted ' +214 ' to 214.

let stringToConvert = " 214 "
try
    let number = Int16.Parse(stringToConvert, CultureInfo.InvariantCulture)
    printfn $"Converted '{stringToConvert}' to {number}." 
with 
| :? FormatException ->
    printfn $"Unable to parse '{stringToConvert}'."
| :? OverflowException ->
    printfn $"'{stringToConvert}' is out of range of the Int16 data type."

let stringToConvert = " + 214"
try
    let number = Int16.Parse(stringToConvert, CultureInfo.InvariantCulture)
    printfn $"Converted '{stringToConvert}' to {number}." 
with 
| :? FormatException ->
    printfn $"Unable to parse '{stringToConvert}'."
| :? OverflowException -> 
    printfn $"'{stringToConvert}' is out of range of the Int16 data type."

let stringToConvert = " +214 "
try
    let number = Int16.Parse(stringToConvert, CultureInfo.InvariantCulture)
    printfn $"Converted '{stringToConvert}' to {number}." 
with
| :? FormatException ->
    printfn $"Unable to parse '{stringToConvert}'."
| :? OverflowException ->
    printfn $"'{stringToConvert}' is out of range of the Int16 data type."

// The example displays the following output to the console:
//       Converted ' 214 ' to 214.
//       Unable to parse ' + 214'.
//       Converted ' +214 ' to 214.

Dim stringToConvert As String
Dim number As Short

stringToConvert = " 214 "
Try
   number = Int16.Parse(stringToConvert, CultureInfo.InvariantCulture)
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, number)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert)
Catch e As OverflowException
   Console.WriteLine("'{0'} is out of range of the Int16 data type.", _
                     stringToConvert)
End Try

stringToConvert = " + 214"                                 
Try
   number = Int16.Parse(stringToConvert, CultureInfo.InvariantCulture)
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, number)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert)
Catch e As OverflowException
   Console.WriteLine("'{0'} is out of range of the Int16 data type.", _
                     stringToConvert)
End Try

stringToConvert = " +214 " 
Try
   number = Int16.Parse(stringToConvert, CultureInfo.InvariantCulture)
   Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, number)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", stringToConvert)
Catch e As OverflowException
   Console.WriteLine("'{0'} is out of range of the Int16 data type.", _
                     stringToConvert)
End Try
' The example displays the following output to the console:
'       Converted ' 214 ' to 214.
'       Unable to parse ' + 214'.
'       Converted ' +214 ' to 214.

Opmerkingen

De s parameter bevat een getal van het formulier:

[ws][sign]digits[ws]

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

Element	Beschrijving
Ws	Een optionele witruimte.
sign	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 decimale cijfers zijn alleen voorloop- en volgspaties in combinatie met een voorloopteken toegestaan.s Als u de stijlelementen expliciet wilt definiëren in combinatie met de cultuurspecifieke opmaakinformatie die aanwezig kan zijn s, gebruikt u de Int16.Parse(String, NumberStyles, IFormatProvider) methode.

De provider parameter is een IFormatProvider implementatie die een NumberFormatInfo object verkrijgt. Het NumberFormatInfo biedt cultuurspecifieke informatie over de indeling van s. Als provider dat het is null, wordt de NumberFormatInfo voor de huidige cultuur gebruikt.

Zie ook

Van toepassing op

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Parseert een reeks UTF-8 tekens in een waarde.

public static short Parse(ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);

static member Parse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider -> int16

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As Short

Parameters

utf8Text: ReadOnlySpan<Byte>

Het bereik van UTF-8 tekens om te parseren.

style: NumberStyles

Een bitsgewijze combinatie van getalstijlen die aanwezig kunnen zijn in utf8Text.

provider: IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie biedt over utf8Text.

Retouren

Int16

Het resultaat van parseren utf8Text.

Implementeringen

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Van toepassing op

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Converteert de spanweergave van een getal in een opgegeven stijl en cultuurspecifieke notatie naar het equivalent van het 16-bits ondertekende gehele getal.

public static short Parse(ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);

public static short Parse(ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider provider = default);

static member Parse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider -> int16

Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As Short

Parameters

s: ReadOnlySpan<Char>

Een bereik met de tekens die het getal vertegenwoordigen dat moet worden geconverteerd.

style: NumberStyles

Een bitsgewijze combinatie van opsommingswaarden die de stijlelementen aangeeft die aanwezig kunnen zijn in s. Een typische waarde die moet worden opgegeven, is Integer.

provider: IFormatProvider

Een IFormatProvider die cultuurspecifieke opmaakinformatie over s.

Retouren

Int16

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

Implementeringen

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Van toepassing op

Parse(String, NumberStyles, IFormatProvider)

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Bron:: Int16.cs

Converteert de tekenreeksweergave van een getal in een opgegeven stijl en cultuurspecifieke notatie naar het equivalent van het 16-bits ondertekende gehele getal.

public:
 static short Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider);

public:
 static short Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<short>::Parse;

public static short Parse(string s, System.Globalization.NumberStyles style, IFormatProvider provider);

public static short Parse(string s, System.Globalization.NumberStyles style, IFormatProvider? provider);

static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> int16

Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As Short

Parameters

s: String

Een tekenreeks die een getal bevat dat moet worden geconverteerd.

style: NumberStyles

Een bitsgewijze combinatie van opsommingswaarden die de stijlelementen aangeeft die aanwezig kunnen zijn in s. Een typische waarde die moet worden opgegeven, is Integer.

provider: IFormatProvider

Een IFormatProvider die cultuurspecifieke opmaakinformatie over s.

Retouren

Int16

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

Implementeringen

Parse(String, NumberStyles, IFormatProvider)

Uitzonderingen

ArgumentNullException

s is null.

ArgumentException

style is geen NumberStyles waarde.

– of –

style is geen combinatie van AllowHexSpecifier en HexNumber waarden.

FormatException

s heeft geen indeling die compatibel is met style.

OverflowException

s vertegenwoordigt een getal kleiner dan Int16.MinValue of groter dan Int16.MaxValue.

– of –

s bevat niet-nul fractionele cijfers.

Voorbeelden

In het volgende voorbeeld worden verschillende style parameters gebruikt provider om de tekenreeksweergaven van Int16 waarden te parseren.

string value;
short number;
NumberStyles style;
CultureInfo provider;

// Parse string using "." as the thousands separator
// and " " as the decimal separator.
value = "19 694,00";
style = NumberStyles.AllowDecimalPoint | NumberStyles.AllowThousands;
provider = new CultureInfo("fr-FR");

number = Int16.Parse(value, style, provider);
Console.WriteLine("'{0}' converted to {1}.", value, number);
// Displays:
//    '19 694,00' converted to 19694.

try
{
   number = Int16.Parse(value, style, CultureInfo.InvariantCulture);
   Console.WriteLine("'{0}' converted to {1}.", value, number);
}
catch (FormatException)
{
   Console.WriteLine("Unable to parse '{0}'.", value);
}
// Displays:
//    Unable to parse '19 694,00'.

// Parse string using "$" as the currency symbol for en_GB and
// en-US cultures.
value = "$6,032.00";
style = NumberStyles.Number | NumberStyles.AllowCurrencySymbol;
provider = new CultureInfo("en-GB");

try
{
   number = Int16.Parse(value, style, CultureInfo.InvariantCulture);
   Console.WriteLine("'{0}' converted to {1}.", value, number);
}
catch (FormatException)
{
   Console.WriteLine("Unable to parse '{0}'.", value);
}
// Displays:
//    Unable to parse '$6,032.00'.

provider = new CultureInfo("en-US");
number = Int16.Parse(value, style, provider);
Console.WriteLine("'{0}' converted to {1}.", value, number);
// Displays:
//    '$6,032.00' converted to 6032.

// Parse string using "." as the thousands separator
// and " " as the decimal separator.
let value = "19 694,00"
let style = NumberStyles.AllowDecimalPoint ||| NumberStyles.AllowThousands
let provider = CultureInfo "fr-FR"

let number = Int16.Parse(value, style, provider)
printfn $"'{value}' converted to {number}." 
// Displays:
//    '19 694,00' converted to 19694.

try
    let number = Int16.Parse(value, style, CultureInfo.InvariantCulture)
    printfn $"'{value}' converted to {number}." 
with :? FormatException ->
    printfn $"Unable to parse '{value}'."
// Displays:
//    Unable to parse '19 694,00'.

// Parse string using "$" as the currency symbol for en_GB and
// en-US cultures.
let value = "$6,032.00"
let style = NumberStyles.Number ||| NumberStyles.AllowCurrencySymbol

try
    let number = Int16.Parse(value, style, CultureInfo.InvariantCulture)
    printfn $"'{value}' converted to {number}." 
with :? FormatException ->
    printfn $"Unable to parse '{value}'."
// Displays:
//    Unable to parse '$6,032.00'.

let provider = CultureInfo "en-US"
let number = Int16.Parse(value, style, provider)
printfn $"'{value}' converted to {number}."
// Displays:
//    '$6,032.00' converted to 6032.

Dim value As String
Dim number As Short
Dim style As NumberStyles
Dim provider As CultureInfo

' Parse string using "." as the thousands separator 
' and " " as the decimal separator.
value = "19 694,00"
style = NumberStyles.AllowDecimalPoint Or NumberStyles.AllowThousands
provider = New CultureInfo("fr-FR")

number = Int16.Parse(value, style, provider)
Console.WriteLine("'{0}' converted to {1}.", value, number)
' Displays:
'    '19 694,00' converted to 19694.

Try
   number = Int16.Parse(value, style, CultureInfo.InvariantCulture)
   Console.WriteLine("'{0}' converted to {1}.", value, number)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", value)
End Try
' Displays:
'    Unable to parse '19 694,00'.

' Parse string using "$" as the currency symbol for en_GB and
' en-US cultures.
value = "$6,032.00"
style = NumberStyles.Number Or NumberStyles.AllowCurrencySymbol
provider = New CultureInfo("en-GB")

Try
   number = Int16.Parse(value, style, CultureInfo.InvariantCulture)
   Console.WriteLine("'{0}' converted to {1}.", value, number)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", value)
End Try
' Displays:
'    Unable to parse '$6,032.00'.
                        
provider = New CultureInfo("en-US")
number = Int16.Parse(value, style, provider)
Console.WriteLine("'{0}' converted to {1}.", value, number)
' Displays:
'    '$6,032.00' converted to 6032.

Opmerkingen

De style parameter definieert de stijlelementen (zoals witruimte of het positieve teken) 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][$][teken][cijfers;]digits[.fractional_digits][e[sign]digits][ws]

Of, indien style opgenomen AllowHexSpecifier:

[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 `style`NumberStyles.AllowLeadingWhite vlag worden weergegeven, of aan het einde van `s` de `style`NumberStyles.AllowTrailingWhite vlag.
$	Een cultuurspecifiek valutasymbool. De positie in de tekenreeks wordt gedefinieerd door de NumberFormatInfo.CurrencyPositivePattern en NumberFormatInfo.CurrencyNegativePattern eigenschappen 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 `style`NumberStyles.AllowLeadingSign vlag worden weergegeven en kan aan het einde van `s` de vlag worden weergegeven.`style`NumberStyles.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 scheidingsteken voor duizendtallen. Het scheidingsteken voor duizendtallen van de huidige cultuur kan worden weergegeven als `sstyle` deze de NumberStyles.AllowThousands vlag bevat.
.	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 reeks van het 0 cijfer. Fractionele cijfers kunnen worden weergegeven als `sstyle` deze de NumberStyles.AllowDecimalPoint vlag bevat. Als een ander cijfer dan 0 wordt weergegeven in fractional_digits, genereert de methode een OverflowException.
e	Het teken e of E, dat aangeeft dat `s` kan worden weergegeven in exponentiële notatie. De `s` parameter kan een getal in exponentiële notatie vertegenwoordigen als `style` deze de NumberStyles.AllowExponent vlag bevat. De `s` parameter moet echter een getal vertegenwoordigen in het gegevensbereik van het Int16 gegevenstype en mag geen niet-nul fractioneel onderdeel hebben.
hexdigits	Een reeks hexadecimale cijfers van 0 tot en met f of 0 tot en met F.

Note

Alle nultekens (U+0000) s worden genegeerd door de parseringsbewerking, ongeacht de waarde van het style argument.

Niet-samengestelde getalstijlwaarden	Elementen die naast cijfers zijn toegestaan
NumberStyles.None	Alleen decimale cijfers.
NumberStyles.AllowDecimalPoint	De elementen . en fractional_digits . Fractional_digits mag echter bestaan uit slechts één of meer cijfers of een OverflowException wordt gegenereerd.
NumberStyles.AllowExponent	De `s` parameter kan ook exponentiële notatie gebruiken.
NumberStyles.AllowLeadingWhite	Het ws-element aan het begin van `s`.
NumberStyles.AllowTrailingWhite	Het ws-element aan het einde van `s`.
NumberStyles.AllowLeadingSign	Een teken kan vóór cijfers worden weergegeven.
NumberStyles.AllowTrailingSign	Een teken kan na cijfers worden weergegeven.
NumberStyles.AllowParentheses	Het tekenelement in de vorm van haakjes tussen de numerieke waarde.
NumberStyles.AllowThousands	Het , element.
NumberStyles.AllowCurrencySymbol	Het $ element.

Als de NumberStyles.AllowHexSpecifier vlag wordt gebruikt, s moet dit de tekenreeksweergave zijn van een hexadecimale waarde zonder voorvoegsel. '9AF3' parseert bijvoorbeeld met succes, maar '0x9AF3' niet.. De enige andere vlaggen die aanwezig kunnen zijn, style zijn NumberStyles.AllowLeadingWhite en NumberStyles.AllowTrailingWhite. (De NumberStyles opsomming heeft een samengestelde getalstijl, NumberStyles.HexNumberdie beide witruimtevlagmen bevat.)

De provider parameter is een IFormatProvider implementatie waarvan de GetFormat methode een NumberFormatInfo object verkrijgt. Het NumberFormatInfo object biedt cultuurspecifieke informatie over de indeling van s. Als provider dat het is null, wordt het NumberFormatInfo object voor de huidige cultuur gebruikt.

Zie ook

Van toepassing op

Feedback

Is deze pagina nuttig?