Int64.Parse Metoda
Definice
Důležité
Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.
Převádí řetězcové vyjádření čísla na 64bitové celé číslo se znaménkem stejné hodnoty.
Přetížení
Parse(String, NumberStyles, IFormatProvider) |
Převede řetězcové vyjádření čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 64bitový celočíselný ekvivalent. |
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) |
Převede reprezentaci rozsahu čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 64bitový celočíselný ekvivalent. |
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider) |
Parsuje rozsah znaků UTF-8 na hodnotu. |
Parse(String, IFormatProvider) |
Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na jeho 64bitové celočíselné číslo se sadou. |
Parse(String) |
Převádí řetězcové vyjádření čísla na 64bitové celé číslo se znaménkem stejné hodnoty. |
Parse(ReadOnlySpan<Char>, IFormatProvider) |
Parsuje rozsah znaků na hodnotu. |
Parse(ReadOnlySpan<Byte>, IFormatProvider) |
Parsuje rozsah znaků UTF-8 na hodnotu. |
Parse(String, NumberStyles) |
Převede řetězcovou reprezentaci čísla v zadaném stylu na jeho ekvivalent 64bitového celočíselného čísla se sadou. |
Parse(String, NumberStyles, IFormatProvider)
- Source:
- Int64.cs
- Source:
- Int64.cs
- Source:
- Int64.cs
Převede řetězcové vyjádření čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 64bitový celočíselný ekvivalent.
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 k převedení.
- style
- NumberStyles
Bitová kombinace hodnot výčtu, která označuje prvky stylu, které mohou být přítomny v s
. Typická hodnota, která se má zadat, je Integer.
- provider
- IFormatProvider
Poskytuje IFormatProvider informace o formátování specifické pro s
jazykovou verzi.
Návraty
64bitové celé číslo se signoum adresou odpovídající číslu zadanému v s
.
Implementuje
Výjimky
s
je null
.
s
není ve formátu kompatibilním s style
.
s
představuje číslo menší než Int64.MinValue nebo větší než Int64.MaxValue.
-nebo-
style
podporuje desetinné číslice, ale s
zahrnuje nenulové desetinné číslice.
Příklady
Následující příklad používá různé style
parametry a provider
k analýze řetězcových Int64 reprezentací hodnot. Ukazuje také některé různé způsoby interpretace stejného řetězce 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é znaky nebo kladné znaménko), které jsou povoleny v parametru s
pro úspěšnou operaci parsování. Musí se jednat o kombinaci bitových příznaků z výčtu NumberStyles . V závislosti na hodnotě style
s
může parametr obsahovat následující prvky:
[ws][$][sign][digits,]digits[.fractional_digits][e[sign]exponential_digits][ws]
Nebo pokud style
obsahuje 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é místo. Pokud příznak obsahujeNumberStyles.AllowLeadingWhite, může se na začátku s style zobrazit prázdné znaky, a pokud style příznak obsahujeNumberStyles.AllowTrailingWhite, může se zobrazit na koncis . |
$ | Symbol měny pro konkrétní 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 NumberStyles.AllowCurrencySymbol příznak . |
sign | Nepovinný znak. Znaménko se může zobrazit na začátku, s pokud style obsahuje NumberStyles.AllowLeadingSign příznak, nebo na konci, s pokud style obsahuje NumberStyles.AllowTrailingSign příznak. Závorky lze v s použít k označení záporné hodnoty, pokud style obsahuje NumberStyles.AllowParentheses příznak. |
Číslic Fractional_digits exponential_digits |
Řada číslic od 0 do 9. |
, | Symbol oddělovače tisíců, specifický pro jazykovou verzi. Oddělovač tisíců jazykové verze určené funkcí provider se může zobrazit v s , pokud style obsahuje NumberStyles.AllowThousands příznak . |
. | Symbol desetinné čárky specifický pro jazykovou verzi. Symbol desetinné čárky jazykové verze určené nástrojem provider se může zobrazit v s , pokud style obsahuje NumberStyles.AllowDecimalPoint příznak .Pouze číslice 0 se může zobrazit jako desetinná číslice pro úspěšnou operaci analýzy; Pokud fractional_digits obsahuje jinou číslici, vyvolá se OverflowException hodnota . |
E | Znak "e" nebo "E", který označuje, že hodnota je vyjádřena v exponenciální notaci. Parametr s může představovat číslo v exponenciálním zápisuNumberStyles.AllowExponent, pokud style obsahuje příznak . |
hexdigits | Posloupnost šestnáctkových číslic od 0 do f nebo id 0 do F. |
Poznámka
Operace analýzy ignoruje všechny ukončující znaky s
NUL (U+0000) bez ohledu na hodnotu argumentu style
.
Řetězec pouze s desítkovými číslicemi (který odpovídá NumberStyles.None stylu) se vždy úspěšně analyzuje, pokud je v rozsahu Int64 typu. Většina zbývajících NumberStyles členů řídí prvky, které mohou být, ale nejsou nutné, aby byly 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
nástroji .
Nesložené hodnoty NumberStyles | Prvky, které jsou povoleny v s, kromě číslic |
---|---|
NumberStyles.None | Pouze desítkové číslice. |
NumberStyles.AllowDecimalPoint | Prvky desetinné čárky ( . ) a desetinné čárky . Desetinné číslice však musí obsahovat pouze jednu nebo více 0 číslic nebo OverflowException je vyvolán. |
NumberStyles.AllowExponent | Parametr s může také používat exponenciální zápis. |
NumberStyles.AllowLeadingWhite | Element ws na začátku .s |
NumberStyles.AllowTrailingWhite | Element ws na konci .s |
NumberStyles.AllowLeadingSign | Před číslicemi se může zobrazit znaménko. |
NumberStyles.AllowTrailingSign | Za číslicemi se může zobrazit znaménko. |
NumberStyles.AllowParentheses | Element sign ve formě závorek ohraničující číselnou hodnotu. |
NumberStyles.AllowThousands | Prvek oddělovače tisíců ( , ) |
NumberStyles.AllowCurrencySymbol | Element .$ |
NumberStyles.AllowHexSpecifier Pokud se použije příznak, s
musí to být šestnáctková hodnota bez předpony. Například C9AF3 úspěšně analyzuje, ale "0xC9AF3" ne. Jedinými dalšími příznaky, které se můžou v style
nástroji vyskytovat, jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles má složený styl čísla , NumberStyles.HexNumberkterý obsahuje oba příznaky prázdných znaků.)
Parametr provider
je implementace, například objekt nebo NumberFormatInfoCultureInfo .IFormatProvider Parametr provider
poskytuje informace specifické pro jazykovou verzi, které se používají při analýze. Pokud provider
je null
, použije se NumberFormatInfo pro aktuální jazykovou verzi.
Viz také
Platí pro
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)
- Source:
- Int64.cs
- Source:
- Int64.cs
- Source:
- Int64.cs
Převede reprezentaci rozsahu čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 64bitový celočíselný 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, která se má zadat, je Integer.
- provider
- IFormatProvider
Poskytuje IFormatProvider informace o formátování specifické pro s
jazykovou verzi.
Návraty
64bitové celé číslo se signoum adresou odpovídající číslu zadanému v s
.
Implementuje
Platí pro
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)
- Source:
- Int64.cs
- Source:
- Int64.cs
Parsuje rozsah znaků UTF-8 na hodnotu.
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, které se mají analyzovat.
- style
- NumberStyles
Bitové kombinace stylů čísel, které se můžou vyskytovat v nástroji utf8Text
.
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátování specifické pro utf8Text
jazykovou verzi.
Návraty
Výsledek analýzy utf8Text
Implementuje
Platí pro
Parse(String, IFormatProvider)
- Source:
- Int64.cs
- Source:
- Int64.cs
- Source:
- Int64.cs
Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na jeho 64bitové celočíselné číslo se sadou.
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 k převedení.
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátování specifické pro s
jazykovou verzi.
Návraty
64bitové celé číslo se signoum adresou odpovídající číslu zadanému v s
.
Implementuje
Výjimky
s
je null
.
s
není ve správném formátu.
s
představuje číslo menší než Int64.MinValue nebo větší než Int64.MaxValue.
Příklady
V následujícím příkladu je obslužná rutina události kliknutí na tlačítko webového formuláře. Používá pole vrácené HttpRequest.UserLanguages vlastností k určení národního prostředí uživatele. Potom vytvoří instanci objektu CultureInfo , který odpovídá danému národnímu prostředí. ObjektNumberFormatInfo, který patří k danému objektuParse(String, IFormatProvider), CultureInfo se pak předá metodě, která převede vstup uživatele na Int64 hodnotu.
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 Int64 hodnotu. Například jej lze 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 ostatní položky jsou následující.
ws Volitelné prázdné znaky.
znaménko volitelné.
digits Posloupnost číslic od 0 do 9.
Parametr se s
interpretuje pomocí NumberStyles.Integer stylu . Kromě desítkových číslic jsou povoleny pouze úvodní a koncové mezery s počátečním znaménkem. Pokud chcete explicitně definovat prvky stylu, které mohou být přítomny v s
, použijte metodu Int64.Parse(String, NumberStyles, IFormatProvider) .
Parametr provider
je implementace, například objekt nebo NumberFormatInfoCultureInfo .IFormatProvider Parametr provider
poskytuje informace specifické pro jazykovou verzi o formátu .s
Pokud provider
je null
, použije se NumberFormatInfo pro aktuální jazykovou verzi.
Viz také
Platí pro
Parse(String)
- Source:
- Int64.cs
- Source:
- Int64.cs
- Source:
- Int64.cs
Převádí řetězcové vyjádření čísla na 64bitové celé číslo se znaménkem stejné hodnoty.
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 k převedení.
Návraty
64bitové celé číslo se signoumm číslem, které odpovídá číslu obsaženému v s
souboru .
Výjimky
s
je null
.
s
není ve správném formátu.
s
představuje číslo menší než Int64.MinValue nebo větší než Int64.MaxValue.
Příklady
Následující příklad ukazuje, jak převést řetězcovou hodnotu na 64bitovou celočíselnou hodnotu se signoum sadou pomocí Int64.Parse(String) metody . 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é místo. |
znak | Nepovinný znak. |
číslice | Řada číslic od 0 do 9. |
Parametr se s
interpretuje pomocí NumberStyles.Integer stylu . Kromě desítkových číslic jsou povoleny pouze úvodní a koncové mezery s počátečním znaménkem. Chcete-li explicitně definovat prvky stylu, které mohou být přítomny v s
, použijte metodu Int64.Parse(String, NumberStyles)Int64.Parse(String, NumberStyles, IFormatProvider) nebo .
Parametr s
je analyzován pomocí informací o formátování v objektu NumberFormatInfo , který je inicializován pro aktuální jazykovou verzi systému. Pokud chcete analyzovat řetězec pomocí informací o formátování nějaké jiné jazykové verze, použijte metodu Int64.Parse(String, NumberStyles, IFormatProvider) .
Viz také
Platí pro
Parse(ReadOnlySpan<Char>, IFormatProvider)
- Source:
- Int64.cs
- Source:
- Int64.cs
- Source:
- Int64.cs
Parsuje rozsah znaků na hodnotu.
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 s
jazykovou verzi.
Návraty
Výsledek analýzy s
Implementuje
Platí pro
Parse(ReadOnlySpan<Byte>, IFormatProvider)
- Source:
- Int64.cs
- Source:
- Int64.cs
Parsuje rozsah znaků UTF-8 na hodnotu.
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, které se mají analyzovat.
- provider
- IFormatProvider
Objekt, který poskytuje informace o formátování specifické pro utf8Text
jazykovou verzi.
Návraty
Výsledek analýzy utf8Text
Implementuje
Platí pro
Parse(String, NumberStyles)
- Source:
- Int64.cs
- Source:
- Int64.cs
- Source:
- Int64.cs
Převede řetězcovou reprezentaci čísla v zadaném stylu na jeho 64bitový celočíselný ekvivalent 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 k převedení.
- style
- NumberStyles
Bitové kombinace NumberStyles hodnot, které označují povolený formát .s
Typická hodnota, která se má zadat, je Integer.
Návraty
64bitové celé číslo se signoum adresou, které odpovídá číslu zadanému v s
souboru .
Výjimky
s
je null
.
s
není ve formátu kompatibilním s style
.
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 daný 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 v parametru s
povolené pro úspěšnou operaci analýzy. Musí se jednat o kombinaci bitových příznaků z výčtu NumberStyles . V závislosti na hodnotě style
s
může parametr obsahovat následující prvky:
[ws][$][sign][digits,]digits[.fractional_digits][e[sign]exponential_digits][ws]
Nebo pokud style
obsahuje 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é místo. Pokud příznak obsahujeNumberStyles.AllowLeadingWhite, může se na začátku s style zobrazit prázdné znaky, a pokud style příznak obsahujeNumberStyles.AllowTrailingWhite, může se zobrazit na koncis . |
$ | Symbol měny pro konkrétní jazykovou verzi. Jeho pozice v řetězci je definována vlastnostmi NumberFormatInfo.CurrencyNegativePattern a NumberFormatInfo.CurrencyPositivePattern aktuální jazykové verze. Symbol měny aktuální jazykové verze se může zobrazit v s , pokud style obsahuje NumberStyles.AllowCurrencySymbol příznak . |
sign | Nepovinný znak. Znaménko se může zobrazit na začátku, s pokud style obsahuje NumberStyles.AllowLeadingSign příznak, a může se zobrazit na konci, s pokud style obsahuje NumberStyles.AllowTrailingSign příznak. Závorky lze v s použít k označení záporné hodnoty, pokud style obsahuje NumberStyles.AllowParentheses příznak. |
Číslic Fractional_digits exponential_digits |
Řada číslic od 0 do 9. Pro fractional_digits je platná pouze číslice 0. |
, | Symbol oddělovače tisíců, specifický pro jazykovou verzi. Oddělovač tisíců aktuální jazykové verze se může zobrazit v s , pokud style obsahuje NumberStyles.AllowThousands příznak. |
. | Symbol desetinné čárky specifický pro jazykovou verzi. Symbol desetinné čárky aktuální jazykové verze se může zobrazit v s , pokud style obsahuje NumberStyles.AllowDecimalPoint příznak. Pouze číslice 0 se může zobrazit jako desetinná číslice, aby operace analýzy byla úspěšná; Pokud fractional_digits obsahuje jakoukoli jinou číslici, vyvolá se znak OverflowException . |
E | Znak "e" nebo "E", který označuje, že hodnota je vyjádřena v exponenciální notaci. Parametr s může představovat číslo v exponenciálním zápisuNumberStyles.AllowExponent, pokud style obsahuje příznak. |
šestihranné | Posloupnost šestnáctkových číslic od 0 do f nebo id 0 do F. |
Poznámka
Operace analýzy ignoruje všechny ukončující ZNAKY NUL (U+0000) bez s
ohledu na hodnotu argumentu style
.
Řetězec pouze s číslicemi (který odpovídá NumberStyles.None stylu) se vždy úspěšně analyzuje, pokud je v rozsahu Int64 typu. Většina zbývajících NumberStyles členů řídí prvky, které můžou 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 nástroji s
.
Hodnota NumberStyles | Prvky, které jsou povoleny v s, kromě číslic |
---|---|
None | Pouze prvek digits . |
AllowDecimalPoint | Desetinná čárka ( . ) a desetinné číslice prvky. |
AllowExponent | Parametr s může také použít exponenciální notaci. Pokud s představuje číslo v exponenciálním zápisu, nemůže výsledná číselná hodnota obsahovat žádné nenulové desetinné číslice. |
AllowLeadingWhite | Element ws na začátku souboru s . |
AllowTrailingWhite | Element ws na konci souboru s . |
AllowLeadingSign | Element sign na začátku objektu s . |
AllowTrailingSign | Element sign na konci objektu s . |
AllowParentheses | Element sign ve formě závorek ohraničující číselnou hodnotu. |
AllowThousands | Element oddělovače tisíců ( , ) |
AllowCurrencySymbol | Element $ . |
Currency | Všechny. Parametr s nemůže představovat šestnáctkové číslo nebo číslo v exponenciálním zápisu. |
Float | Element ws na začátku nebo na konci znaku s , znaménko na začátku s a symbol desetinné čárky ( . ) Parametr s může také použít exponenciální notaci. |
Number | Elementy ws, sign, thousands oddělovač ( , ) a desetinná čárka ( . ) |
Any | Všechny styly s výjimkou s nemohou představovat šestnáctkové číslo. |
Pokud se NumberStyles.AllowHexSpecifier použije příznak, s
musí být šestnáctková hodnota bez předpony. Například "C9AF3" parsuje úspěšně, ale "0xC9AF3" ne. Jedinými dalšími příznaky, které je možné kombinovat s parametrem s
, jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles obsahuje složený styl čísla , NumberStyles.HexNumberkterý zahrnuje oba příznaky prázdných znaků.)
Parametr s
se analyzuje pomocí informací o formátování v objektu NumberFormatInfo , který je inicializován pro aktuální jazykovou verzi systému. Pokud chcete určit jazykovou verzi, jejíž informace o formátování se používají pro operaci analýzy, zavolejte Int64.Parse(String, NumberStyles, IFormatProvider) přetížení.
Viz také
Platí pro
Váš názor
https://aka.ms/ContentUserFeedback.
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu:Odeslat a zobrazit názory pro