Int64.Parse Metod

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

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

Parametrar

Returer

Ett 64-bitars signerat heltal som motsvarar talet i s.

Undantag

Exempel

I följande exempel visas hur du konverterar ett strängvärde till ett 64-bitars signerat heltalsvärde med hjälp av Int64.Parse(String) metoden. Det visar sedan det resulterande långa heltalsvärdet.

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.

Kommentarer

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

[ws][sign]digits[ws]

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

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

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

Parametern s parsas med formateringsinformationen i ett NumberFormatInfo objekt som initieras för den aktuella systemkulturen. Om du vill parsa en sträng med formateringsinformationen för någon annan kultur använder du Int64.Parse(String, NumberStyles, IFormatProvider) metoden .

Se även

• ToString()
• Parsing Numeriska strängar i .NET

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

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

Parametrar

Returer

Resultatet av parsning utf8Text.

Implementeringar

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

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

Parametrar

Returer

Resultatet av parsning s.

Implementeringar

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

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

Parametrar

Returer

Ett 64-bitars signerat heltal som motsvarar det nummer som anges i s.

Undantag

Exempel

I följande exempel används Int64.Parse(String, NumberStyles) metoden för att parsa strängrepresentationerna av flera Int64 värden. Den aktuella kulturen för exemplet är 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'.

Kommentarer

Parametern style definierar formatelementen (till exempel blanksteg, symbolen för positiva eller negativa tecken eller tusentalsavgränsningssymbolen) som tillåts i parametern s för att parsningsåtgärden ska lyckas. Det måste vara en kombination av bitflaggor från NumberStyles uppräkningen. Beroende på värdet för stylekan parametern s innehålla följande element:

[ws][$][sign][digits,]digits[.fractional_digits][e[sign]exponential_digits][ws]

Eller, om style inkluderar AllowHexSpecifier:

[ws]hexdigits[ws]

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

Element	Description
Ws	Valfritt blanksteg. Tomt utrymme kan visas i början av s om style innehåller NumberStyles.AllowLeadingWhite flaggan, och det kan visas i slutet av s om style innehåller NumberStyles.AllowTrailingWhite flaggan.
$	En kulturspecifik valutasymbol. Dess position i strängen definieras av NumberFormatInfo.CurrencyNegativePattern egenskaperna och NumberFormatInfo.CurrencyPositivePattern för den aktuella kulturen. Den aktuella kulturens valutasymbol kan visas i s om style den NumberStyles.AllowCurrencySymbol innehåller flaggan.
signera	Ett valfritt tecken. Tecknet kan visas i början av s om style innehåller NumberStyles.AllowLeadingSign flaggan, och det kan visas i slutet av s om style innehåller NumberStyles.AllowTrailingSign flaggan. Parenteser kan användas i s för att ange ett negativt värde om style den NumberStyles.AllowParentheses innehåller flaggan.
Siffror fractional_digits exponential_digits	En sekvens med siffror från 0 till 9. För fractional_digits är endast siffran 0 giltig.
,	En kulturspecifik tusentalsavgränsare. Den aktuella kulturens tusentalsavgränsare kan visas i s om style den NumberStyles.AllowThousands innehåller flaggan.
.	Ett kulturspecifikt decimaltecken. Den aktuella kulturens decimaltecken kan visas i s om style den NumberStyles.AllowDecimalPoint innehåller flaggan. Endast siffran 0 kan visas som en bråktalssiffra för att parsningsåtgärden ska lyckas. Om fractional_digits innehåller någon annan siffra genereras en OverflowException .
e	Tecknet "e" eller "E", som anger att värdet representeras i exponentiell notation. Parametern s kan representera ett tal i exponentiell notation om style den NumberStyles.AllowExponent innehåller flaggan.
hexdigits	En sekvens med hexadecimala siffror från 0 till f eller 0 till och med F.

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

NumberStyles-värde	Element som tillåts i s utöver siffror
None	Endast elementet digits .
AllowDecimalPoint	Decimaltecknet ( . ) och bråksiffriga element.
AllowExponent	Parametern s kan också använda exponentiell notation. Om s representerar ett tal i exponentiell notation kan det resulterande numeriska värdet inte innehålla några bråksiffror som inte är noll.
AllowLeadingWhite	WS-elementet i början av s.
AllowTrailingWhite	WS-elementet i slutet av s.
AllowLeadingSign	Teckenelementet i början av s.
AllowTrailingSign	Teckenelementet i slutet av s.
AllowParentheses	Teckenelementet i form av parenteser som omger det numeriska värdet.
AllowThousands	Tusentalsavgränsaren ( , ) elementet.
AllowCurrencySymbol	Elementet $ .
Currency	Alla. Parametern s kan inte representera ett hexadecimalt tal eller ett tal i exponentiell notation.
Float	WS-elementet i början eller slutet av s, tecknet i början av soch decimaltecknet ( . ) . Parametern s kan också använda exponentiell notation.
Number	Elementen ws, sign, thousands separator ( , ), och decimaltecknet ( . ) .
Any	Alla format, förutom s kan inte representera ett hexadecimalt tal.

NumberStyles.AllowHexSpecifier Om flaggan används s måste vara ett hexadecimalt värde utan prefix. Till exempel parsar "C9AF3" korrekt, men "0xC9AF3" gör det inte. De enda andra flaggorna som kan kombineras med parametern s är NumberStyles.AllowLeadingWhite och NumberStyles.AllowTrailingWhite. (Uppräkningen NumberStyles innehåller ett sammansatt talformat, NumberStyles.HexNumber, som innehåller båda blankstegsflaggorna.)

Parametern s parsas med formateringsinformationen i ett NumberFormatInfo objekt som initieras för den aktuella systemkulturen. Om du vill ange den kultur vars formateringsinformation används för parsningsåtgärden anropar du överlagringen Int64.Parse(String, NumberStyles, IFormatProvider) .

Se även

• ToString()
• TryParse
• Parsing Numeriska strängar i .NET

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

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

Parametrar

Returer

Ett 64-bitars signerat heltal som motsvarar det nummer som anges i s.

Implementeringar

Undantag

Exempel

Följande exempel är knappklickshändelsehanteraren för ett webbformulär. Den använder matrisen som returneras av HttpRequest.UserLanguages egenskapen för att fastställa användarens nationella inställningar. Det instansierar sedan ett CultureInfo objekt som motsvarar det nationella språket. Objektet NumberFormatInfo som tillhör objektet CultureInfo skickas sedan till Parse(String, IFormatProvider) metoden för att konvertera användarens indata till ett Int64 värde.

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

Kommentarer

Den här överlagringen Parse(String, IFormatProvider) av metoden används vanligtvis för att konvertera text som kan formateras på flera olika sätt till ett Int64 värde. Den kan till exempel användas för att konvertera texten som en användare har angett till en HTML-textruta till ett numeriskt värde.

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

[ws][sign]digits[ws]

Objekt inom hakparenteser ([ och ]) är valfria och andra objekt är följande.

ws Ett valfritt tomt utrymme.

signera Ett valfritt tecken.

digits En sekvens med siffror från 0 till 9.

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

Parametern provider är en IFormatProvider implementering, till exempel ett objekt eller NumberFormatInfo ett CultureInfo objekt. Parametern provider tillhandahåller kulturspecifik information om formatet för s. Om provider är nullNumberFormatInfo används för den aktuella kulturen.

Se även

• ToString()
• TryParse
• Parsing Numeriska strängar i .NET

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

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

Parametrar

Returer

Resultatet av parsning utf8Text.

Implementeringar

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

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

Parametrar

Returer

Ett 64-bitars signerat heltal som motsvarar det nummer som anges i s.

Implementeringar

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

Källa:

Int64.cs

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

Parametrar

Returer

Ett 64-bitars signerat heltal som motsvarar det nummer som anges i s.

Implementeringar

Undantag

Exempel

I följande exempel används en mängd style olika parametrar för provider att parsa strängrepresentationerna av Int64 värden. Det illustrerar också några av de olika sätt som samma sträng kan tolkas på beroende på vilken kultur vars formateringsinformation används för parsningsåtgärden.

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.

Kommentarer

Parametern style definierar formatelementen (till exempel tomt utrymme eller det positiva tecknet) som tillåts i parametern s för att parsningsåtgärden ska lyckas. Det måste vara en kombination av bitflaggor från NumberStyles uppräkningen. Beroende på värdet för stylekan parametern s innehålla följande element:

[ws][$][sign][digits,]digits[.fractional_digits][e[sign]exponential_digits][ws]

Eller, om style inkluderar AllowHexSpecifier:

[ws]hexdigits[ws]

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

Element	Description
Ws	Valfritt blanksteg. Tomt utrymme kan visas i början av s om style innehåller NumberStyles.AllowLeadingWhite flaggan, och det kan visas i slutet av s om style innehåller NumberStyles.AllowTrailingWhite flaggan.
$	En kulturspecifik valutasymbol. Dess position i strängen definieras av NumberFormatInfo.CurrencyPositivePattern egenskapen för objektet NumberFormatInfo som returneras av GetFormat parametermetoden provider . Valutasymbolen kan visas i s om style den NumberStyles.AllowCurrencySymbol innehåller flaggan.
signera	Ett valfritt tecken. Tecknet kan visas i början av s om style innehåller NumberStyles.AllowLeadingSign flaggan eller i slutet av s om style innehåller NumberStyles.AllowTrailingSign flaggan. Parenteser kan användas i s för att ange ett negativt värde om style den NumberStyles.AllowParentheses innehåller flaggan.
Siffror fractional_digits exponential_digits	En sekvens med siffror från 0 till 9.
,	En kulturspecifik tusentalsavgränsare. Tusentalsavgränsaren för kulturen som anges av provider kan visas i s om style den NumberStyles.AllowThousands innehåller flaggan.
.	Ett kulturspecifikt decimaltecken. Decimaltecknet för kulturen som anges av provider kan visas i s om style den NumberStyles.AllowDecimalPoint innehåller flaggan. Endast siffran 0 kan visas som en bråktalssiffra för att parsningsåtgärden ska lyckas. Om fractional_digits innehåller någon annan siffra genereras en OverflowException .
e	Tecknet "e" eller "E", som anger att värdet representeras i exponentiell notation. Parametern s kan representera ett tal i exponentiell notation om style den NumberStyles.AllowExponent innehåller flaggan.
hexdigits	En sekvens med hexadecimala siffror från 0 till f eller 0 till och med F.

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

Icke-sammansatta NumberStyles-värden	Element som tillåts i s utöver siffror
NumberStyles.None	Endast decimalsiffror.
NumberStyles.AllowDecimalPoint	Decimaltecknet ( . ) och bråksiffriga element. Bråktal måste dock bara bestå av en eller flera 0 siffror eller så genereras enOverflowException.
NumberStyles.AllowExponent	Parametern s kan också använda exponentiell notation.
NumberStyles.AllowLeadingWhite	WS-elementet i början av s.
NumberStyles.AllowTrailingWhite	WS-elementet i slutet av s.
NumberStyles.AllowLeadingSign	Ett tecken kan visas före siffror.
NumberStyles.AllowTrailingSign	Ett tecken kan visas efter siffror.
NumberStyles.AllowParentheses	Teckenelementet i form av parenteser som omger det numeriska värdet.
NumberStyles.AllowThousands	Tusentalsavgränsaren ( , ) elementet.
NumberStyles.AllowCurrencySymbol	Elementet $ .

NumberStyles.AllowHexSpecifier Om flaggan används s måste vara ett hexadecimalt värde utan prefix. Till exempel parsar "C9AF3" korrekt, men "0xC9AF3" gör det inte. De enda andra flaggorna som kan finnas i style är NumberStyles.AllowLeadingWhite och NumberStyles.AllowTrailingWhite. (Uppräkningen NumberStyles har ett sammansatt talformat, NumberStyles.HexNumber, som innehåller båda blankstegsflaggorna.)

Parametern provider är en IFormatProvider implementering, till exempel ett objekt eller NumberFormatInfo ett CultureInfo objekt. Parametern provider tillhandahåller kulturspecifik information som används vid parsning. Om provider är nullNumberFormatInfo används för den aktuella kulturen.

Se även

• ToString()
• Parsing Numeriska strängar i .NET