Sdílet prostřednictvím

Int64.Parse Metoda

  • Reference

Definice

Obor názvů:
System
Sestavení:
System.Runtime.dll
Sestavení:
mscorlib.dll
Sestavení:
netstandard.dll

Převede řetězcové vyjádření čísla na jeho 64bitové celé číslo se znaky.

Přetížení

Parse(String)

Převede řetězcové vyjádření čísla na jeho 64bitové celé číslo se znaky.
Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parsuje rozsah znaků UTF-8 do hodnoty.
Parse(ReadOnlySpan<Char>, IFormatProvider)

Parsuje rozsah znaků do hodnoty.
Parse(String, NumberStyles)

Převede řetězcovou reprezentaci čísla v zadaném stylu na 64bitový ekvivalent celého čísla se znaky.
Parse(String, IFormatProvider)

Převede řetězcové vyjádření čísla v zadaném formátu specifickém pro jazykovou verzi na jeho 64bitový ekvivalent celého čísla se znaky.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parsuje rozsah znaků UTF-8 do hodnoty.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Převede reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 64bitový celočíselnou ekvivalent.
Parse(String, NumberStyles, IFormatProvider)

Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 64bitový ekvivalent celého čísla.

Parse(String)

Zdroj:
Int64.cs
Zdroj:
Int64.cs
Zdroj:
Int64.cs

Převede řetězcové vyjádření čísla na jeho 64bitové celé číslo se znaky.

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

Parametry

s
String

Řetězec obsahující číslo, které chcete převést.

Návraty

Int64

64bitové celé číslo se signedm ekvivalentní číslu obsaženému v s.

Výjimky

ArgumentNullException

s je null.

FormatException

s není ve správném formátu.

OverflowException

s představuje číslo menší než Int64.MinValue nebo větší než Int64.MaxValue.

Příklady

Následující příklad ukazuje, jak pomocí metody Int64.Parse(String) převést řetězcovou hodnotu na 64bitovou celočíselnou hodnotu se znaky signed. Zobrazí výslednou dlouhou celočíselnou hodnotu.

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.

Poznámky

Parametr s obsahuje číslo formuláře:

[ws] [sign]digits[ws]

Prvky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element Popis
Ws Volitelné prázdné znaky.
podepsat Volitelné znaménko.
číslice Posloupnost číslic v rozsahu od 0 do 9

Parametr s se interpretuje pomocí stylu NumberStyles.Integer. Kromě desetinných číslic jsou povoleny pouze úvodní a koncové mezery spolu s počátečním znakem. Chcete-li explicitně definovat prvky stylu, které mohou být přítomny v s, použijte Int64.Parse(String, NumberStyles) nebo Int64.Parse(String, NumberStyles, IFormatProvider) metoda.

Parametr s se analyzuje pomocí informací o formátování v objektu NumberFormatInfo inicializovaném pro aktuální jazykovou verzi systému. K analýze řetězce pomocí informací o formátování některé jiné jazykové verze použijte metodu Int64.Parse(String, NumberStyles, IFormatProvider).

Viz také

Platí pro

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Zdroj:
Int64.cs
Zdroj:
Int64.cs

Parsuje rozsah znaků UTF-8 do hodnoty.

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

Parametry

utf8Text
ReadOnlySpan<Byte>

Rozsah znaků UTF-8 pro analýzu.

provider
IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi o utf8Text.

Návraty

Int64

Výsledek analýzy utf8Text.

Implementuje

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Platí pro

Parse(ReadOnlySpan<Char>, IFormatProvider)

Zdroj:
Int64.cs
Zdroj:
Int64.cs
Zdroj:
Int64.cs

Parsuje rozsah znaků do hodnoty.

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

Parametry

s
ReadOnlySpan<Char>

Rozsah znaků, které se mají analyzovat.

provider
IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi o s.

Návraty

Int64

Výsledek analýzy s.

Implementuje

Parse(ReadOnlySpan<Char>, IFormatProvider)

Platí pro

Parse(String, NumberStyles)

Zdroj:
Int64.cs
Zdroj:
Int64.cs
Zdroj:
Int64.cs

Převede řetězcovou reprezentaci čísla v zadaném stylu na 64bitový ekvivalent celého čísla se znaky.

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

Parametry

s
String

Řetězec obsahující číslo, které chcete převést.

style
NumberStyles

Bitové kombinace NumberStyles hodnot, které označují povolený formát s. Typická hodnota pro zadání je Integer.

Návraty

Int64

64bitové celé číslo se signedm odpovídající číslu zadanému v s.

Výjimky

ArgumentNullException

s je null.

ArgumentException

style není NumberStyles hodnota.

-nebo-

style není kombinací hodnot AllowHexSpecifier a HexNumber.

FormatException

s není ve formátu kompatibilním s style.

OverflowException

s představuje číslo menší než Int64.MinValue nebo větší než Int64.MaxValue.

-nebo-

style podporuje desetinné číslice, ale s obsahuje nenulové desetinné číslice.

Příklady

Následující příklad používá metodu Int64.Parse(String, NumberStyles) k analýze řetězcových reprezentací několika Int64 hodnot. Aktuální jazyková verze pro příklad je 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'.

Poznámky

Parametr style definuje prvky stylu (například prázdné znaky, symbol kladného nebo záporného znaménka nebo symbol oddělovače tisíců), které jsou povolené v parametru s, aby operace analýzy byla úspěšná. Musí se jednat o kombinaci bitových příznaků z NumberStyles výčtu. V závislosti na hodnotě stylemůže parametr s obsahovat následující prvky:

[ws] [$] [znaménko] [digits,]digits[.fractional_digits][e[sign]exponential_digits][ws]

Pokud style zahrnuje AllowHexSpecifier:

[ws]hexdigits[ws]

Prvky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element Popis
ws Volitelné prázdné znaky. Prázdné znaky se můžou objevit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingWhite a může se zobrazit na konci s, pokud style obsahuje příznak NumberStyles.AllowTrailingWhite.
$ Symbol měny specifický pro jazykovou verzi. Jeho pozice v řetězci je definována NumberFormatInfo.CurrencyNegativePattern a NumberFormatInfo.CurrencyPositivePattern vlastnosti aktuální jazykové verze. Symbol měny aktuální jazykové verze se může zobrazit v s, pokud style obsahuje příznak NumberStyles.AllowCurrencySymbol.
znaménko Volitelné znaménko. Znaménko se může zobrazit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingSign a může se zobrazit na konci s, pokud style obsahuje příznak NumberStyles.AllowTrailingSign. Závorky lze použít v s k označení záporné hodnoty, pokud style obsahuje příznak NumberStyles.AllowParentheses.
číslice

fractional_digits

exponential_digits		 Posloupnost číslic od 0 do 9. Pro fractional_digitsje platná pouze číslice 0.
, Symbol oddělovače tisíců specifických pro jazykovou verzi. Oddělovač tisíců aktuální jazykové verze se může zobrazit v s, pokud style obsahuje příznak NumberStyles.AllowThousands.
. Symbol desetinné čárky specifické pro jazykovou verzi. Symbol desetinné čárky aktuální jazykové verze se může zobrazit v s, pokud style obsahuje příznak NumberStyles.AllowDecimalPoint. Pouze číslice 0 se může zobrazit jako desetinná číslice pro úspěšnou operaci analýzy; pokud fractional_digits obsahuje jakoukoli jinou číslici, vyvolá se OverflowException.
e Znak "e" nebo "E", který označuje, že hodnota je reprezentována exponenciálním zápisem. Parametr s může představovat číslo v exponenciálním zápisu, pokud style obsahuje příznak NumberStyles.AllowExponent.
šestnáctkové Posloupnost šestnáctkových číslic od 0 do f nebo 0 až F.

Poznámka

Všechny ukončující NUL (U+0000) znaky v s jsou ignorovány operací analýzy bez ohledu na hodnotu argumentu style.

Řetězec pouze s číslicemi (který odpovídá stylu NumberStyles.None) se vždy úspěšně parsuje, pokud je v rozsahu typu Int64. Většina zbývajících NumberStyles členů ovládací prvky, které mohou být, ale nemusí být přítomny ve vstupním řetězci. Následující tabulka uvádí, jak jednotlivé NumberStyles členy ovlivňují prvky, které mohou být přítomny v s.

Hodnota NumberStyles Prvky povolené v s kromě číslic
None Pouze číslice prvek.
AllowDecimalPoint Desetinná čárka ( . ) a desetinné číslice prvky.
AllowExponent Parametr s může také použít exponenciální zápis. Pokud s představuje číslo v exponenciálním zápisu, výsledná číselná hodnota nemůže obsahovat žádné nenulové desetinné číslice.
AllowLeadingWhite Prvek ws na začátku s.
AllowTrailingWhite Prvek ws na konci s.
AllowLeadingSign Znak prvek na začátku s.
AllowTrailingSign Znak prvek na konci s.
AllowParentheses Znak prvek ve formě závorek ohraničující číselnou hodnotu.
AllowThousands Oddělovač tisíců ( , ) – element.
AllowCurrencySymbol Prvek $.
Currency Všichni. Parametr s nemůže představovat šestnáctkové číslo nebo číslo v exponenciálním zápisu.
Float Prvek ws na začátku nebo konci s, znaménko na začátku sa symbol desetinné čárky (. ). Parametr s může také použít exponenciální zápis.
Number Prvky ws, znaménko, oddělovač tisíců ( , ) a desetinná čárka (.).
Any Všechny styly s výjimkou s nemohou představovat šestnáctkové číslo.

Pokud se použije příznak NumberStyles.AllowHexSpecifier, s musí být šestnáctková hodnota bez předpony. Například "C9AF3" se úspěšně parsuje, ale "0xC9AF3" ne. Jedinými dalšími příznaky, které lze kombinovat s parametrem s, jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles zahrnuje složený styl čísla, NumberStyles.HexNumber, který obsahuje oba příznaky prázdných znaků.)

Parametr s se analyzuje pomocí informací o formátování v objektu NumberFormatInfo inicializovaném pro aktuální jazykovou verzi systému. Chcete-li určit jazykovou verzi, jejíž informace formátování se používají pro operaci analýzy, zavolejte Int64.Parse(String, NumberStyles, IFormatProvider) přetížení.

Viz také

Platí pro

Parse(String, IFormatProvider)

Zdroj:
Int64.cs
Zdroj:
Int64.cs
Zdroj:
Int64.cs

Převede řetězcové vyjádření čísla v zadaném formátu specifickém pro jazykovou verzi na jeho 64bitový ekvivalent celého čísla se znaky.

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

Parametry

s
String

Řetězec obsahující číslo, které chcete převést.

provider
IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi o s.

Návraty

Int64

64bitové celé číslo se signedm odpovídající číslu zadanému v s.

Implementuje

Parse(String, IFormatProvider)

Výjimky

ArgumentNullException

s je null.

FormatException

s není ve správném formátu.

OverflowException

s představuje číslo menší než Int64.MinValue nebo větší než Int64.MaxValue.

Příklady

Následující příklad je obslužná rutina události kliknutí na tlačítko webového formuláře. Používá pole vrácené vlastností HttpRequest.UserLanguages k určení národního prostředí uživatele. Potom vytvoří instanci CultureInfo objektu, který odpovídá danému národnímu prostředí. Objekt NumberFormatInfo, který patří do daného CultureInfo objektu, se pak předá metodě Parse(String, IFormatProvider), která převede vstup uživatele na hodnotu Int64.

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

Poznámky

Toto přetížení Parse(String, IFormatProvider) metody se obvykle používá k převodu textu, který lze formátovat různými způsoby na hodnotu Int64. Dá se například použít k převodu textu zadaného uživatelem do textového pole HTML na číselnou hodnotu.

Parametr s obsahuje číslo formuláře:

[ws] [sign]digits[ws]

Položky v hranatých závorkách ([ a ]) jsou volitelné a další položky jsou následující.

ws Volitelné prázdné znaky.

podepište volitelné znaménko.

číslice: Posloupnost číslic v rozsahu od 0 do 9.

Parametr s se interpretuje pomocí stylu NumberStyles.Integer. Kromě desetinných číslic jsou povoleny pouze úvodní a koncové mezery spolu s počátečním znakem. Chcete-li explicitně definovat prvky stylu, které mohou být přítomny v s, použijte Int64.Parse(String, NumberStyles, IFormatProvider) metoda.

Parametr provider je IFormatProvider implementace, například NumberFormatInfo nebo objekt CultureInfo. Parametr provider poskytuje informace specifické pro jazykovou verzi o formátu s. Pokud je providernull, použije se NumberFormatInfo pro aktuální jazykovou verzi.

Viz také

Platí pro

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Zdroj:
Int64.cs
Zdroj:
Int64.cs

Parsuje rozsah znaků UTF-8 do hodnoty.

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

Parametry

utf8Text
ReadOnlySpan<Byte>

Rozsah znaků UTF-8 pro analýzu.

style
NumberStyles

Bitové kombinace stylů čísel, které mohou být přítomny v utf8Text.

provider
IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi o utf8Text.

Návraty

Int64

Výsledek analýzy utf8Text.

Implementuje

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Platí pro

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Zdroj:
Int64.cs
Zdroj:
Int64.cs
Zdroj:
Int64.cs

Převede reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 64bitový celočíselnou ekvivalent.

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

Parametry

s
ReadOnlySpan<Char>

Rozsah obsahující znaky představující číslo, které se má převést.

style
NumberStyles

Bitová kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v s. Typická hodnota pro zadání je Integer.

provider
IFormatProvider

IFormatProvider, který poskytuje informace o formátování specifické pro jazykovou verzi o s.

Návraty

Int64

64bitové celé číslo se signedm odpovídající číslu zadanému v s.

Implementuje

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Platí pro

Parse(String, NumberStyles, IFormatProvider)

Zdroj:
Int64.cs
Zdroj:
Int64.cs
Zdroj:
Int64.cs

Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 64bitový ekvivalent celého čísla.

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

Parametry

s
String

Řetězec obsahující číslo, které chcete převést.

style
NumberStyles

Bitová kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v s. Typická hodnota pro zadání je Integer.

provider
IFormatProvider

IFormatProvider, který poskytuje informace o formátování specifické pro jazykovou verzi o s.

Návraty

Int64

64bitové celé číslo se signedm odpovídající číslu zadanému v s.

Implementuje

Parse(String, NumberStyles, IFormatProvider)

Výjimky

ArgumentNullException

s je null.

ArgumentException

style není NumberStyles hodnota.

-nebo-

style není kombinací hodnot AllowHexSpecifier a HexNumber.

FormatException

s není ve formátu kompatibilním s style.

OverflowException

s představuje číslo menší než Int64.MinValue nebo větší než Int64.MaxValue.

-nebo-

style podporuje desetinné číslice, ale s obsahuje nenulové desetinné číslice.

Příklady

Následující příklad používá k analýze řetězcových reprezentací hodnot Int64 různé parametry style a provider. Ukazuje také některé z různých způsobů, jak lze stejný řetězec interpretovat v závislosti na jazykové verzi, jejíž informace o formátování se používají pro operaci analýzy.

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.

Poznámky

Parametr style definuje prvky stylu (například prázdné znaménko nebo kladné znaménko), které jsou povolené v parametru s, aby operace analýzy byla úspěšná. Musí se jednat o kombinaci bitových příznaků z NumberStyles výčtu. V závislosti na hodnotě stylemůže parametr s obsahovat následující prvky:

[ws] [$] [znaménko] [digits,]digits[.fractional_digits][e[sign]exponential_digits][ws]

Pokud style zahrnuje AllowHexSpecifier:

[ws]hexdigits[ws]

Prvky v hranatých závorkách ([ a ]) jsou volitelné. Následující tabulka popisuje jednotlivé prvky.

Element Popis
ws Volitelné prázdné znaky. Prázdné znaky se můžou objevit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingWhite a může se zobrazit na konci s, pokud style obsahuje příznak NumberStyles.AllowTrailingWhite.
$ Symbol měny specifický pro jazykovou verzi. Jeho pozice v řetězci je definována NumberFormatInfo.CurrencyPositivePattern vlastnost objektu NumberFormatInfo vrácenou GetFormat metodou parametru provider. Symbol měny se může zobrazit v s, pokud style obsahuje příznak NumberStyles.AllowCurrencySymbol.
znaménko Volitelné znaménko. Znaménko se může zobrazit na začátku s, pokud style obsahuje příznak NumberStyles.AllowLeadingSign nebo na konci s, pokud style obsahuje příznak NumberStyles.AllowTrailingSign. Závorky lze použít v s k označení záporné hodnoty, pokud style obsahuje příznak NumberStyles.AllowParentheses.
číslice

fractional_digits

exponential_digits		 Posloupnost číslic od 0 do 9.
, Symbol oddělovače tisíců specifických pro jazykovou verzi. Oddělovač tisíců jazykové verze určené provider se může objevit v s, pokud style obsahuje příznak NumberStyles.AllowThousands.
. Symbol desetinné čárky specifické pro jazykovou verzi. Symbol desetinné čárky jazykové verze určené provider se může objevit v s, pokud style obsahuje příznak NumberStyles.AllowDecimalPoint.

Pouze číslice 0 se může zobrazit jako desetinná číslice pro úspěšnou operaci analýzy; pokud fractional_digits obsahuje jakoukoli jinou číslici, vyvolá se OverflowException.
e Znak "e" nebo "E", který označuje, že hodnota je reprezentována exponenciálním zápisem. Parametr s může představovat číslo v exponenciálním zápisu, pokud style obsahuje příznak NumberStyles.AllowExponent.
šestnáctkové Posloupnost šestnáctkových číslic od 0 do f nebo 0 až F.

Poznámka

Všechny ukončující NUL (U+0000) znaky v s jsou ignorovány operací analýzy bez ohledu na hodnotu argumentu style.

Řetězec s desetinnými číslicemi (který odpovídá stylu NumberStyles.None) se vždy úspěšně parsuje, pokud je v rozsahu typu Int64. Většina zbývajících NumberStyles členů ovládací prvky, které mohou být, ale nemusí být přítomny v tomto vstupním řetězci. Následující tabulka uvádí, jak jednotlivé NumberStyles členy ovlivňují prvky, které mohou být přítomny v s.

Neseparované hodnoty NumberStyles Prvky povolené v s kromě číslic
NumberStyles.None Pouze desítkové číslice.
NumberStyles.AllowDecimalPoint Desetinná čárka ( . ) a desetinné číslice prvky. desetinné číslice však musí obsahovat pouze jednu nebo více 0 číslic nebo je vyvolán OverflowException.
NumberStyles.AllowExponent Parametr s může také použít exponenciální zápis.
NumberStyles.AllowLeadingWhite Prvek ws na začátku s.
NumberStyles.AllowTrailingWhite Prvek ws na konci s.
NumberStyles.AllowLeadingSign Znak se může zobrazit před číslicemi.
NumberStyles.AllowTrailingSign Znak se může zobrazit po číslicích.
NumberStyles.AllowParentheses Znak prvek ve formě závorek ohraničující číselnou hodnotu.
NumberStyles.AllowThousands Oddělovač tisíců ( , ) – element.
NumberStyles.AllowCurrencySymbol Prvek $.

Pokud se použije příznak NumberStyles.AllowHexSpecifier, s musí být šestnáctková hodnota bez předpony. Například "C9AF3" se úspěšně parsuje, ale "0xC9AF3" ne. Jedinými dalšími příznaky, které mohou být přítomné v style, jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles má složený styl čísla, NumberStyles.HexNumber, který obsahuje oba příznaky prázdných znaků.)

Parametr provider je IFormatProvider implementace, například NumberFormatInfo nebo objekt CultureInfo. Parametr provider poskytuje informace specifické pro jazykovou verzi používané při analýze. Pokud je providernull, použije se NumberFormatInfo pro aktuální jazykovou verzi.

Viz také

Platí pro