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

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

Overloads

Name Description
Parse(String)

Converteert de tekenreeksweergave van een getal naar het 64-bits equivalent van het 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 64-bits ondertekende gehele getal.
Parse(String, IFormatProvider)

Converteert de tekenreeksweergave van een getal in een opgegeven cultuurspecifieke indeling naar het equivalent van het 64-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 64-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 64-bits ondertekende gehele getal.

Parse(String)

Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs

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

public:
 static long Parse(System::String ^ s);
public static long Parse(string s);
static member Parse : string -> int64
Public Shared Function Parse (s As String) As Long

Parameters

s
String

Een tekenreeks die een getal bevat dat moet worden geconverteerd.

Retouren

Int64

Een 64-bits ondertekend 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 Int64.MinValue of groter dan Int64.MaxValue.

Voorbeelden

In het volgende voorbeeld ziet u hoe u een tekenreekswaarde converteert naar een 64-bits geheel getal met behulp van de Int64.Parse(String) methode. Vervolgens wordt de resulterende lange gehele waarde weergegeven.

using System;

public class ParseInt64
{
   public static void Main()
   {
      Convert("  179042  ");
      Convert(" -2041326 ");
      Convert(" +8091522 ");
      Convert("   1064.0   ");
      Convert("  178.3");
      Convert(String.Empty);
      Convert(((decimal) Int64.MaxValue) + 1.ToString());
   }

   private static void Convert(string value)
   {
      try
      {
         long number = Int64.Parse(value);
         Console.WriteLine("Converted '{0}' to {1}.", value, number);
      }
      catch (FormatException)
      {
         Console.WriteLine("Unable to convert '{0}'.", value);
      }
      catch (OverflowException)
      {
         Console.WriteLine("'{0}' is out of range.", value);
      }
   }
}
// This example displays the following output to the console:
//       Converted '  179042  ' to 179042.
//       Converted ' -2041326 ' to -2041326.
//       Converted ' +8091522 ' to 8091522.
//       Unable to convert '   1064.0   '.
//       Unable to convert '  178.3'.
//       Unable to convert ''.
//       '92233720368547758071' is out of range.

open System

let convert value =
    try
        let number = Int64.Parse value
        printfn $"Converted '{value}' to {number}."
    with
    | :? FormatException ->
        printfn $"Unable to convert '{value}'."
    | :? OverflowException ->
        printfn $"'{value}' is out of range."

convert "  179042  "
convert " -2041326 "
convert " +8091522 "
convert "   1064.0   "
convert "  178.3"
convert String.Empty

decimal Int64.MaxValue + 1M
|> string
|> convert

// This example displays the following output to the console:
//       Converted '  179042  ' to 179042.
//       Converted ' -2041326 ' to -2041326.
//       Converted ' +8091522 ' to 8091522.
//       Unable to convert '   1064.0   '.
//       Unable to convert '  178.3'.
//       Unable to convert ''.
//       '92233720368547758071' is out of range.

Module ParseInt64
   Public Sub Main()
      Convert("  179032  ")
      Convert(" -2041326 ")
      Convert(" +8091522 ")
      Convert("   1064.0   ")
      Convert("  178.3")
      Convert(String.Empty)
      Convert((CDec(Int64.MaxValue) + 1).ToString())
   End Sub

   Private Sub Convert(value As String)
      Try
         Dim number As Long = Int64.Parse(value)
         Console.WriteLine("Converted '{0}' to {1}.", value, number)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", value)
      Catch e As OverflowException
         Console.WriteLine("'{0}' is out of range.", value)      
      End Try
   End Sub
End Module
' This example displays the following output to the console:
'       Converted '  179032  ' to 179032.
'       Converted ' -2041326 ' to -2041326.
'       Converted ' +8091522 ' to 8091522.
'       Unable to convert '   1064.0   '.
'       Unable to convert '  178.3'.
'       Unable to convert ''.
'       '9223372036854775808' is out of range.

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.
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 met een voorloopteken toegestaan. Als u expliciet de stijlelementen wilt definiëren waarin u aanwezig kunt zijn s, gebruikt u de Int64.Parse(String, NumberStyles) of de Int64.Parse(String, NumberStyles, IFormatProvider) methode.

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

Zie ook

Van toepassing op

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs

Parseert een reeks UTF-8 tekens in een waarde.

public:
 static long Parse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider) = IUtf8SpanParsable<long>::Parse;
public static long Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider);
static member Parse : ReadOnlySpan<byte> * IFormatProvider -> int64
Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider) As Long

Parameters

utf8Text
ReadOnlySpan<Byte>

Het bereik van UTF-8 tekens om te parseren.

provider
IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie biedt over utf8Text.

Retouren

Int64

Het resultaat van parseren utf8Text.

Implementeringen

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Van toepassing op

Parse(ReadOnlySpan<Char>, IFormatProvider)

Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs

Parseert een reeks tekens in een waarde.

public:
 static long Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<long>::Parse;
public static long Parse(ReadOnlySpan<char> s, IFormatProvider? provider);
static member Parse : ReadOnlySpan<char> * IFormatProvider -> int64
Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As Long

Parameters

s
ReadOnlySpan<Char>

De reeks tekens die moeten worden geparseerd.

provider
IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie biedt over s.

Retouren

Int64

Het resultaat van parseren s.

Implementeringen

Parse(ReadOnlySpan<Char>, IFormatProvider)

Van toepassing op

Parse(String, NumberStyles)

Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs

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

public:
 static long Parse(System::String ^ s, System::Globalization::NumberStyles style);
public static long Parse(string s, System.Globalization.NumberStyles style);
static member Parse : string * System.Globalization.NumberStyles -> int64
Public Shared Function Parse (s As String, style As NumberStyles) As Long

Parameters

s
String

Een tekenreeks die een getal bevat dat moet worden geconverteerd.

style
NumberStyles

Een bitsgewijze combinatie van NumberStyles waarden die de toegestane notatie van s. Een typische waarde die moet worden opgegeven, is Integer.

Retouren

Int64

Een 64-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 Int64.MinValue of groter dan Int64.MaxValue.

– of –

style ondersteunt fractionele cijfers, maar s bevat niet-nul fractionele cijfers.

Voorbeelden

In het volgende voorbeeld wordt de Int64.Parse(String, NumberStyles) methode gebruikt om de tekenreeksweergaven van verschillende Int64 waarden te parseren. De huidige cultuur voor het voorbeeld is en-US.

using System;
using System.Globalization;

public class ParseInt32
{
   public static void Main()
   {
      Convert("104.0", NumberStyles.AllowDecimalPoint);
      Convert("104.9", NumberStyles.AllowDecimalPoint);
      Convert (" 106034", NumberStyles.None);
      Convert(" $17,198,064.42", NumberStyles.AllowCurrencySymbol |
                                 NumberStyles.Number);
      Convert(" $17,198,064.00", NumberStyles.AllowCurrencySymbol |
                                 NumberStyles.Number);
      Convert("103E06", NumberStyles.AllowExponent);
      Convert("1200E-02", NumberStyles.AllowExponent);
      Convert("1200E-03", NumberStyles.AllowExponent);
      Convert("-1,345,791", NumberStyles.AllowThousands);
      Convert("(1,345,791)", NumberStyles.AllowThousands |
                             NumberStyles.AllowParentheses);
      Convert("FFCA00A0", NumberStyles.HexNumber);
      Convert("0xFFCA00A0", NumberStyles.HexNumber);
   }

   private static void Convert(string value, NumberStyles style)
   {
      try
      {
         long number = Int64.Parse(value, style);
         Console.WriteLine("Converted '{0}' to {1}.", value, number);
      }
      catch (FormatException)
      {
         Console.WriteLine("Unable to convert '{0}'.", value);
      }
      catch (OverflowException)
      {
         Console.WriteLine("'{0}' is out of range of the Int64 type.", value);
      }
   }
}
// The example displays the following output to the console:
//       Converted '104.0' to 104.
//       '104.9' is out of range of the Int64 type.
//       Unable to convert ' 106034'.
//       ' $17,198,064.42' is out of range of the Int64 type.
//       Converted ' $17,198,064.00' to 17198064.
//       Converted '103E06' to 103000000.
//       Converted '1200E-02' to 12.
//       '1200E-03' is out of range of the Int64 type.
//       Unable to convert '-1,345,791'.
//       Converted '(1,345,791)' to -1345791.
//       Converted 'FFCA00A0' to 4291428512.
//       Unable to convert '0xFFCA00A0'.

open System
open System.Globalization

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

convert "104.0" NumberStyles.AllowDecimalPoint
convert "104.9" NumberStyles.AllowDecimalPoint
convert " 106034" NumberStyles.None
convert " $17,198,064.42" (NumberStyles.AllowCurrencySymbol ||| NumberStyles.Number)
convert " $17,198,064.00" (NumberStyles.AllowCurrencySymbol ||| NumberStyles.Number)
convert "103E06" NumberStyles.AllowExponent
convert "1200E-02" NumberStyles.AllowExponent
convert "1200E-03" NumberStyles.AllowExponent
convert "-1,345,791" NumberStyles.AllowThousands
convert "(1,345,791)" (NumberStyles.AllowThousands ||| NumberStyles.AllowParentheses)
convert "FFCA00A0" NumberStyles.HexNumber
convert "0xFFCA00A0" NumberStyles.HexNumber


// The example displays the following output to the console:
//       converted '104.0' to 104.
//       '104.9' is out of range of the Int64 type.
//       Unable to convert ' 106034'.
//       ' $17,198,064.42' is out of range of the Int64 type.
//       converted ' $17,198,064.00' to 17198064.
//       converted '103E06' to 103000000.
//       converted '1200E-02' to 12.
//       '1200E-03' is out of range of the Int64 type.
//       Unable to convert '-1,345,791'.
//       converted '(1,345,791)' to -1345791.
//       converted 'FFCA00A0' to 4291428512.
//       Unable to convert '0xFFCA00A0'.

Imports System.Globalization

Module ParseInt64
   Public Sub Main()
      Convert("104.0", NumberStyles.AllowDecimalPoint)    
      Convert("104.9", NumberStyles.AllowDecimalPoint)
      Convert (" 106034", NumberStyles.None)
      Convert(" $17,198,064.42", NumberStyles.AllowCurrencySymbol Or _
                                 NumberStyles.Number)
      Convert(" $17,198,064.00", NumberStyles.AllowCurrencySymbol Or _
                                 NumberStyles.Number)
      Convert("103E06", NumberStyles.AllowExponent)  
      Convert("1200E-02", NumberStyles.AllowExponent)
      Convert("1200E-03", NumberStyles.AllowExponent)
      Convert("-1,345,791", NumberStyles.AllowThousands)
      Convert("(1,345,791)", NumberStyles.AllowThousands Or _
                             NumberStyles.AllowParentheses)
      Convert("FFCA00A0", NumberStyles.HexNumber)                       
      Convert("0xFFCA00A0", NumberStyles.HexNumber)                       
   End Sub
   
   Private Sub Convert(value As String, style As NumberStyles)
      Try
         Dim number As Long = Int64.Parse(value, style)
         Console.WriteLine("Converted '{0}' to {1}.", value, number)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", value)
      Catch e As OverflowException
         Console.WriteLine("'{0}' is out of range of the Int64 type.", value)   
      End Try
   End Sub
End Module
' The example displays the following output to the console:
'       Converted '104.0' to 104.
'       '104.9' is out of range of the Int64 type.
'       Unable to convert ' 106034'.
'       ' $17,198,064.42' is out of range of the Int64 type.
'       Converted ' $17,198,064.00' to 17198064.
'       Converted '103E06' to 103000000.
'       Converted '1200E-02' to 12.
'       '1200E-03' is out of range of the Int64 type.
'       Unable to convert '-1,345,791'.
'       Converted '(1,345,791)' to -1345791.
'       Converted 'FFCA00A0' to 4291428512.
'       Unable to convert '0xFFCA00A0'.

Opmerkingen

De style parameter definieert de stijlelementen (zoals witruimte, het positieve of negatieve tekensymbool of het scheidingsteken voor duizendtallen) die zijn toegestaan in de s parameter om de parseringsbewerking te voltooien. 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]exponential_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 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.CurrencyNegativePattern en NumberFormatInfo.CurrencyPositivePattern 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 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

fractional_digits

exponential_digits		 Een reeks cijfers van 0 tot en met 9. Voor fractional_digits is alleen het cijfer 0 geldig.
, Een cultuurspecifiek scheidingsteken voor duizendtallen. Het scheidingsteken voor duizendtallen van de huidige cultuur kan worden weergegeven s als style 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. Alleen het cijfer 0 kan worden weergegeven als een breukcijfer om de parseringsbewerking te laten slagen; als fractional_digits een ander cijfer bevat, wordt er een OverflowException gegenereerd.
e Het teken e of E, dat aangeeft dat de waarde wordt weergegeven in exponentiële notatie. 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.

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 goed als deze zich in het bereik van het Int64 type bevindt. De meeste resterende NumberStyles leden bepalen elementen die mogelijk wel aanwezig zijn in de invoertekenreeks, maar die mogelijk niet aanwezig zijn. De volgende tabel geeft aan hoe afzonderlijke NumberStyles leden van invloed zijn op de elementen die aanwezig kunnen zijn in s.

NumberStyles-waarde Elementen die naast cijfers zijn toegestaan
None Alleen het cijferelement .
AllowDecimalPoint De decimale komma ( . ) en fractionele cijfers .
AllowExponent De s parameter kan ook exponentiële notatie gebruiken. Als s een getal in exponentiële notatie aangeeft, kan de resulterende numerieke waarde geen niet-nul fractionele cijfers bevatten.
AllowLeadingWhite Het ws-element aan het begin van s.
AllowTrailingWhite Het ws-element aan het einde van s.
AllowLeadingSign Het tekenelement aan het begin van s.
AllowTrailingSign Het tekenelement aan het einde van s.
AllowParentheses Het tekenelement in de vorm van haakjes tussen de numerieke waarde.
AllowThousands Het scheidingsteken voor duizendtallen ( , ) .
AllowCurrencySymbol Het $ element.
Currency Alles. De s parameter kan geen hexadecimaal getal of een getal in exponentiële notatie vertegenwoordigen.
Float Het ws-element aan het begin of einde van s, het teken aan het begin van sen het decimaalteken ( . ) De s parameter kan ook exponentiële notatie gebruiken.
Number De ws-, teken-, scheidingstekens voor duizendtallen ( , ) en decimaalteken ( . ) elementen.
Any Alle stijlen, behalve s geen hexadecimaal getal.

Als de NumberStyles.AllowHexSpecifier vlag wordt gebruikt, s moet een hexadecimale waarde zonder voorvoegsel zijn. C9AF3 parseert bijvoorbeeld met succes, maar '0xC9AF3' niet. De enige andere vlaggen die kunnen worden gecombineerd met de s parameter zijn NumberStyles.AllowLeadingWhite en NumberStyles.AllowTrailingWhite. (De NumberStyles opsomming bevat 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. Als u de cultuur wilt opgeven waarvan de opmaakgegevens worden gebruikt voor de parseringsbewerking, roept u de Int64.Parse(String, NumberStyles, IFormatProvider) overbelasting aan.

Zie ook

Van toepassing op

Parse(String, IFormatProvider)

Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs

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

public:
 static long Parse(System::String ^ s, IFormatProvider ^ provider);
public:
 static long Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<long>::Parse;
public static long Parse(string s, IFormatProvider provider);
public static long Parse(string s, IFormatProvider? provider);
static member Parse : string * IFormatProvider -> int64
Public Shared Function Parse (s As String, provider As IFormatProvider) As Long

Parameters

s
String

Een tekenreeks die een getal bevat dat moet worden geconverteerd.

provider
IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie over slevert.

Retouren

Int64

Een 64-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 Int64.MinValue of groter dan Int64.MaxValue.

Voorbeelden

Het volgende voorbeeld is de knop klik op gebeurtenishandler van een webformulier. Hierbij wordt de matrix gebruikt die door de HttpRequest.UserLanguages eigenschap wordt geretourneerd om de landinstelling van de gebruiker te bepalen. Vervolgens wordt een CultureInfo object geïnstitueert dat overeenkomt met die landinstelling. Het NumberFormatInfo object dat bij dat CultureInfo object hoort, wordt vervolgens doorgegeven aan de Parse(String, IFormatProvider) methode om de invoer van de gebruiker te converteren naar een Int64 waarde.

protected void OkToLong_Click(object sender, EventArgs e)
{
    string locale;
    long number;
    CultureInfo culture;

    // Return if string is empty
    if (String.IsNullOrEmpty(this.inputNumber.Text))
        return;

    // Get locale of web request to determine possible format of number
    if (Request.UserLanguages.Length == 0)
        return;
    locale = Request.UserLanguages[0];
    if (String.IsNullOrEmpty(locale))
        return;

    // Instantiate CultureInfo object for the user's locale
    culture = new CultureInfo(locale);

    // Convert user input from a string to a number
    try
    {
        number = Int64.Parse(this.inputNumber.Text, culture.NumberFormat);
    }
    catch (FormatException)
    {
        return;
    }
    catch (Exception)
    {
        return;
    }
    // Output number to label on web form
    this.outputNumber.Text = "Number is " + number.ToString();
}

Protected Sub OkToLong_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles OkToLong.Click
    Dim locale As String
    Dim culture As CultureInfo
    Dim number As Long

    ' Return if string is empty
    If String.IsNullOrEmpty(Me.inputNumber.Text) Then Exit Sub

    ' Get locale of web request to determine possible format of number
    If Request.UserLanguages.Length = 0 Then Exit Sub
    locale = Request.UserLanguages(0)
    If String.IsNullOrEmpty(locale) Then Exit Sub

    ' Instantiate CultureInfo object for the user's locale
    culture = New CultureInfo(locale)

    ' Convert user input from a string to a number
    Try
        number = Int64.Parse(Me.inputNumber.Text, culture.NumberFormat)
    Catch ex As FormatException
        Exit Sub
    Catch ex As Exception
        Exit Sub
    End Try

    ' Output number to label on web form
    Me.outputNumber.Text = "Number is " & number.ToString()
End Sub

Opmerkingen

Deze overbelasting van de Parse(String, IFormatProvider) methode wordt meestal gebruikt om tekst te converteren die op verschillende manieren kan worden opgemaakt naar een Int64 waarde. Het kan bijvoorbeeld worden gebruikt om de tekst die door een gebruiker is ingevoerd, te converteren naar een HTML-tekstvak naar een numerieke waarde.

De s parameter bevat een getal van het formulier:

[ws][sign]digits[ws]

Items in vierkante haken ([ en ]) zijn optioneel en andere items zijn als volgt.

ws Een optionele witruimte.

een optioneel teken ondertekenen.

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 met een voorloopteken toegestaan. Gebruik de s methode om expliciet de stijlelementen te definiëren waarin aanwezig kan zijnInt64.Parse(String, NumberStyles, IFormatProvider).

De provider parameter is een IFormatProvider implementatie, zoals een NumberFormatInfo of CultureInfo object. De provider parameter levert 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:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs

Parseert een reeks UTF-8 tekens in een waarde.

public static long Parse(ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);
static member Parse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider -> int64
Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As Long

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

Int64

Het resultaat van parseren utf8Text.

Implementeringen

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Van toepassing op

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs

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

public static long Parse(ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);
public static long Parse(ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider provider = default);
static member Parse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider -> int64
Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As Long

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

Int64

Een 64-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:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs
Bron:
Int64.cs

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

public:
 static long Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider);
public:
 static long Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<long>::Parse;
public static long Parse(string s, System.Globalization.NumberStyles style, IFormatProvider provider);
public static long Parse(string s, System.Globalization.NumberStyles style, IFormatProvider? provider);
static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> int64
Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As Long

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

Int64

Een 64-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 Int64.MinValue of groter dan Int64.MaxValue.

– of –

style ondersteunt fractionele cijfers, maar s bevat niet-nul fractionele cijfers.

Voorbeelden

In het volgende voorbeeld worden verschillende style parameters gebruikt provider om de tekenreeksweergaven van Int64 waarden te parseren. Het illustreert ook een aantal van de verschillende manieren waarop dezelfde tekenreeks kan worden geïnterpreteerd, afhankelijk van de cultuur waarvan de opmaakgegevens worden gebruikt voor de parseringsbewerking.

using System;
using System.Globalization;

public class ParseInt64
{
   public static void Main()
   {
      Convert("12,000", NumberStyles.Float | NumberStyles.AllowThousands,
              new CultureInfo("en-GB"));
      Convert("12,000", NumberStyles.Float | NumberStyles.AllowThousands,
              new CultureInfo("fr-FR"));
      Convert("12,000", NumberStyles.Float, new CultureInfo("en-US"));

      Convert("12 425,00", NumberStyles.Float | NumberStyles.AllowThousands,
              new CultureInfo("sv-SE"));
      Convert("12,425.00", NumberStyles.Float | NumberStyles.AllowThousands,
              NumberFormatInfo.InvariantInfo);
      Convert("631,900", NumberStyles.Integer | NumberStyles.AllowDecimalPoint,
              new CultureInfo("fr-FR"));
      Convert("631,900", NumberStyles.Integer | NumberStyles.AllowDecimalPoint,
              new CultureInfo("en-US"));
      Convert("631,900", NumberStyles.Integer | NumberStyles.AllowThousands,
              new CultureInfo("en-US"));
   }

   private static void Convert(string value, NumberStyles style,
                               IFormatProvider provider)
   {
      try
      {
         long number = Int64.Parse(value, style, provider);
         Console.WriteLine("Converted '{0}' to {1}.", value, number);
      }
      catch (FormatException)
      {
         Console.WriteLine("Unable to convert '{0}'.", value);
      }
      catch (OverflowException)
      {
         Console.WriteLine("'{0}' is out of range of the Int64 type.", value);
      }
   }
}
// This example displays the following output to the console:
//       Converted '12,000' to 12000.
//       Converted '12,000' to 12.
//       Unable to convert '12,000'.
//       Converted '12 425,00' to 12425.
//       Converted '12,425.00' to 12425.
//       '631,900' is out of range of the Int64 type.
//       Unable to convert '631,900'.
//       Converted '631,900' to 631900.

open System
open System.Globalization

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

convert "12,000" (NumberStyles.Float ||| NumberStyles.AllowThousands) (CultureInfo "en-GB")
convert "12,000" (NumberStyles.Float ||| NumberStyles.AllowThousands) (CultureInfo "fr-FR")
convert "12,000" NumberStyles.Float (CultureInfo "en-US")
convert "12 425,00" (NumberStyles.Float ||| NumberStyles.AllowThousands) (CultureInfo "sv-SE")
convert "12,425.00" (NumberStyles.Float ||| NumberStyles.AllowThousands) NumberFormatInfo.InvariantInfo
convert "631,900" (NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint) (CultureInfo "fr-FR")
convert "631,900" (NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint) (CultureInfo "en-US")
convert "631,900" (NumberStyles.Integer ||| NumberStyles.AllowThousands) (CultureInfo "en-US")

// This example displays the following output to the console:
//       Converted '12,000' to 12000.
//       Converted '12,000' to 12.
//       Unable to convert '12,000'.
//       Converted '12 425,00' to 12425.
//       Converted '12,425.00' to 12425.
//       '631,900' is out of range of the Int64 type.
//       Unable to convert '631,900'.
//       Converted '631,900' to 631900.

Imports System.Globalization

Module ParseInt64
   Public Sub Main()
      Convert("12,000", NumberStyles.Float Or NumberStyles.AllowThousands, _
              New CultureInfo("en-GB"))      
      Convert("12,000", NumberStyles.Float Or NumberStyles.AllowThousands, _
              New CultureInfo("fr-FR"))
      Convert("12,000", NumberStyles.Float, New CultureInfo("en-US"))
      
      Convert("12 425,00", NumberStyles.Float Or NumberStyles.AllowThousands, _
              New CultureInfo("sv-SE")) 
      Convert("12,425.00", NumberStyles.Float Or NumberStyles.AllowThousands, _
              NumberFormatInfo.InvariantInfo) 
      Convert("631,900", NumberStyles.Integer Or NumberStyles.AllowDecimalPoint, _ 
              New CultureInfo("fr-FR"))
      Convert("631,900", NumberStyles.Integer Or NumberStyles.AllowDecimalPoint, _
              New CultureInfo("en-US"))
      Convert("631,900", NumberStyles.Integer Or NumberStyles.AllowThousands, _
              New CultureInfo("en-US"))
   End Sub

   Private Sub Convert(value As String, style As NumberStyles, _
                       provider As IFormatProvider)
      Try
         Dim number As Long = Int64.Parse(value, style, provider)
         Console.WriteLine("Converted '{0}' to {1}.", value, number)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", value)
      Catch e As OverflowException
         Console.WriteLine("'{0}' is out of range of the Int64 type.", value)   
      End Try
   End Sub                       
End Module
' This example displays the following output to the console:
'       Converted '12,000' to 12000.
'       Converted '12,000' to 12.
'       Unable to convert '12,000'.
'       Converted '12 425,00' to 12425.
'       Converted '12,425.00' to 12425.
'       '631,900' is out of range of the Int64 type.
'       Unable to convert '631,900'.
'       Converted '631,900' to 631900.

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]exponential_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 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 het NumberFormatInfo object dat wordt geretourneerd door de GetFormat methode van de provider parameter. Het valutasymbool kan worden weergegeven s als style deze de NumberStyles.AllowCurrencySymbol vlag bevat.
ondertekenen Een optioneel teken. Het teken kan worden weergegeven aan het begin van s als style de NumberStyles.AllowLeadingSign vlag of aan het einde van s de style vlag 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

fractional_digits

exponential_digits		 Een reeks cijfers van 0 tot en met 9.
, Een cultuurspecifiek scheidingsteken voor duizendtallen. Het scheidingsteken voor duizendtallen van de cultuur die is opgegeven door provider , kan worden weergegeven s als style de NumberStyles.AllowThousands vlag wordt opgenomen.
. Een cultuurspecifiek decimaalteken. Het decimaalteken van de cultuur die is opgegeven door provider , kan worden weergegeven s als style de NumberStyles.AllowDecimalPoint vlag wordt opgenomen.

Alleen het cijfer 0 kan worden weergegeven als een breukcijfer om de parseringsbewerking te laten slagen; als fractional_digits een ander cijfer bevat, wordt er een OverflowException gegenereerd.
e Het teken e of E, dat aangeeft dat de waarde wordt weergegeven in exponentiële notatie. 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.

Note

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

Een tekenreeks met alleen decimale cijfers (die overeenkomt met de NumberStyles.None stijl) wordt altijd geparseerd als deze zich in het bereik van het Int64 type bevindt. 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 decimale komma ( . ) en fractionele cijfers . Fractionele cijfers mogen echter slechts uit één of meer 0 cijfers bestaan of een OverflowException getal 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 scheidingsteken voor duizendtallen ( , ) .
NumberStyles.AllowCurrencySymbol Het $ element.

Als de NumberStyles.AllowHexSpecifier vlag wordt gebruikt, s moet een hexadecimale waarde zonder voorvoegsel zijn. C9AF3 parseert bijvoorbeeld met succes, maar '0xC9AF3' 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, zoals een NumberFormatInfo of CultureInfo object. De provider parameter levert cultuurspecifieke informatie die wordt gebruikt bij parseren. Als provider dat het is null, wordt de NumberFormatInfo voor de huidige cultuur gebruikt.

Zie ook

Van toepassing op