Sdílet prostřednictvím


Int32.TryParse Metoda

Definice

Převede řetězcové vyjádření čísla na jeho 32bitové celé číslo se znaky. Vrácená hodnota označuje, jestli operace proběhla úspěšně.

Přetížení

TryParse(String, IFormatProvider, Int32)

Pokusí se analyzovat řetězec do hodnoty.

TryParse(ReadOnlySpan<Char>, Int32)

Převede reprezentaci čísla ve formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselnou ekvivalent. Vrácená hodnota označuje, zda byl převod úspěšný.

TryParse(String, Int32)

Převede řetězcové vyjádření čísla na jeho 32bitové celé číslo se znaky. Vrácená hodnota označuje, zda byl převod úspěšný.

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Int32)

Pokusí se analyzovat rozsah znaků UTF-8 do hodnoty.

TryParse(ReadOnlySpan<Char>, IFormatProvider, Int32)

Pokusí se analyzovat rozsah znaků do hodnoty.

TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Int32)

Pokusí se analyzovat rozsah znaků UTF-8 do hodnoty.

TryParse(ReadOnlySpan<Byte>, Int32)

Pokusí se převést rozsah znaků UTF-8 obsahující řetězcovou reprezentaci čísla na jeho 32bitové celé číslo se znaménkem.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int32)

Převede reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselnou ekvivalent. Vrácená hodnota označuje, zda byl převod úspěšný.

TryParse(String, NumberStyles, IFormatProvider, Int32)

Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na 32bitové celé číslo se znaky. Vrácená hodnota označuje, zda byl převod úspěšný.

TryParse(String, IFormatProvider, Int32)

Zdroj:
Int32.cs
Zdroj:
Int32.cs
Zdroj:
Int32.cs

Pokusí se analyzovat řetězec do hodnoty.

public:
 static bool TryParse(System::String ^ s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result) = IParsable<int>::TryParse;
public static bool TryParse (string? s, IFormatProvider? provider, out int result);
static member TryParse : string * IFormatProvider * int -> bool
Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As Integer) As Boolean

Parametry

s
String

Řetězec, který se má analyzovat.

provider
IFormatProvider

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

result
Int32

Pokud tato metoda vrátí, obsahuje výsledek úspěšné analýzy s nebo nedefinovanou hodnotu při selhání.

Návraty

true, pokud se s úspěšně parsoval; jinak false.

Platí pro

TryParse(ReadOnlySpan<Char>, Int32)

Zdroj:
Int32.cs
Zdroj:
Int32.cs
Zdroj:
Int32.cs

Převede reprezentaci čísla ve formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselnou ekvivalent. Vrácená hodnota označuje, zda byl převod úspěšný.

public:
 static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] int % result);
public static bool TryParse (ReadOnlySpan<char> s, out int result);
static member TryParse : ReadOnlySpan<char> * int -> bool
Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As Integer) As Boolean

Parametry

s
ReadOnlySpan<Char>

Rozsah obsahující znaky, které představují číslo k převodu.

result
Int32

Pokud tato metoda vrátí, obsahuje 32bitové signed celé číslo ekvivalentní číslo obsažené v s, pokud převod byl úspěšný, nebo nula v případě selhání převodu. Převod selže, pokud je parametr snull nebo Empty nebo představuje číslo menší než Int32.MinValue nebo větší než Int32.MaxValue. Tento parametr je předán neinicializovaný; všechny hodnoty původně zadané v result budou přepsány.

Návraty

true, pokud byl s úspěšně převeden; jinak false.

Platí pro

TryParse(String, Int32)

Zdroj:
Int32.cs
Zdroj:
Int32.cs
Zdroj:
Int32.cs

Převede řetězcové vyjádření čísla na jeho 32bitové celé číslo se znaky. Vrácená hodnota označuje, zda byl převod úspěšný.

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] int % result);
public static bool TryParse (string s, out int result);
public static bool TryParse (string? s, out int result);
static member TryParse : string * int -> bool
Public Shared Function TryParse (s As String, ByRef result As Integer) As Boolean

Parametry

s
String

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

result
Int32

Pokud tato metoda vrátí, obsahuje 32bitové signed celé číslo ekvivalentní číslo obsažené v s, pokud převod byl úspěšný, nebo nula v případě selhání převodu. Převod selže, pokud je parametr snull nebo Empty, není ve správném formátu nebo představuje číslo menší než Int32.MinValue nebo větší než Int32.MaxValue. Tento parametr je předán neinicializovaný; všechny hodnoty původně zadané v result budou přepsány.

Návraty

true, pokud byl s úspěšně převeden; jinak false.

Příklady

Následující příklad volá metodu Int32.TryParse(String, Int32) s několika různými řetězcovými hodnotami.

using namespace System;


   void TryToParse(String^ value)
   {
      Int32 number;
      bool result = Int32::TryParse(value, number);
      if (result) {
         Console::WriteLine("Converted '{0}' to {1}.", value, number);
      }
      else {
         if (value == nullptr) value = "";
         Console::WriteLine("Attempted conversion of '{0}' failed.", value);
      }
   }


void main()
{
      TryToParse(nullptr);
      TryToParse("160519");
      TryToParse("9432.0");
      TryToParse("16,667");
      TryToParse("   -322   ");
      TryToParse("+4302");
      TryToParse("(100);");
      TryToParse("01FA");
}
// The example displays the following output:
//      Attempted conversion of '' failed.
//      Converted '160519' to 160519.
//      Attempted conversion of '9432.0' failed.
//      Attempted conversion of '16,667' failed.
//      Converted '   -322   ' to -322.
//      Converted '+4302' to 4302.
//      Attempted conversion of '(100);' failed.
//      Attempted conversion of '01FA' failed.
using System;

public class Example
{
   public static void Main()
   {
      string[] values = { null, "160519", "9432.0", "16,667",
                          "   -322   ", "+4302", "(100);", "01FA" };
      foreach (var value in values)
      {
         int number;

         bool success = int.TryParse(value, out number);
         if (success)
         {
            Console.WriteLine($"Converted '{value}' to {number}.");
         }
         else
         {
            Console.WriteLine($"Attempted conversion of '{value ?? "<null>"}' failed.");
         }
      }
   }
}
// The example displays the following output:
//       Attempted conversion of '<null>' failed.
//       Converted '160519' to 160519.
//       Attempted conversion of '9432.0' failed.
//       Attempted conversion of '16,667' failed.
//       Converted '   -322   ' to -322.
//       Converted '+4302' to 4302.
//       Attempted conversion of '(100);' failed.
//       Attempted conversion of '01FA' failed.
open System

let values = 
   [ null; "160519"; "9432.0"; "16,667"
     "   -322   "; "+4302"; "(100);"; "01FA" ]
for value in values do
    match Int32.TryParse value with
    | true, number -> 
        printfn $"Converted '{value}' to {number}."
    | _ -> 
        printfn $"""Attempted conversion of '{if isNull value then "<null>" else value}' failed."""
         
// The example displays the following output:
//       Attempted conversion of '<null>' failed.
//       Converted '160519' to 160519.
//       Attempted conversion of '9432.0' failed.
//       Attempted conversion of '16,667' failed.
//       Converted '   -322   ' to -322.
//       Converted '+4302' to 4302.
//       Attempted conversion of '(100);' failed.
//       Attempted conversion of '01FA' failed.
Module Example
   Public Sub Main()
      Dim values() As String = { Nothing, "160519", "9432.0", "16,667",
                                 "   -322   ", "+4302", "(100);", 
                                 "01FA" }

      For Each value In values
         Dim number As Integer
    
         Dim success As Boolean = Int32.TryParse(value, number)
         If success Then
            Console.WriteLine("Converted '{0}' to {1}.", value, number)
         Else
            Console.WriteLine("Attempted conversion of '{0}' failed.", 
                              If(value ,"<null>"))
         End If     
      Next
   End Sub
End Module
' The example displays the following output to the console:
'       Attempted conversion of '<null>' failed.
'       Converted '160519' to 160519.
'       Attempted conversion of '9432.0' failed.
'       Attempted conversion of '16,667' failed.
'       Converted '   -322   ' to -322.
'       Converted '+4302' to 4302.
'       Attempted conversion of '(100)' failed.
'       Attempted conversion of '01FA' failed.

Některé řetězce, které metoda TryParse(String, Int32) nemůže převést v tomto příkladu, jsou:

  • "9432.0". Převod selže, protože řetězec nemůže obsahovat oddělovač desetinných míst; musí obsahovat pouze integrální číslice.

  • "16,667". Převod selže, protože řetězec nemůže obsahovat oddělovače skupin; musí obsahovat pouze integrální číslice.

  • "(100)". Převod selže, protože řetězec nemůže obsahovat jiné záporné znaménko než ten definovaný NumberFormatInfo.NegativeSign aktuální jazykové verze a vlastnosti NumberFormatInfo.NumberNegativePattern.

  • "01FA". Převod selže, protože řetězec nemůže obsahovat šestnáctkové číslice; musí obsahovat pouze desítkové číslice.

Poznámky

Metoda TryParse je podobná metodě Parse, s výjimkou TryParse metoda nevyvolá výjimku, pokud převod selže. Eliminuje potřebu použití zpracování výjimek k otestování FormatException v případě, že s je neplatný a nelze jej úspěšně analyzovat.

Parametr s obsahuje číslo formuláře:

[ws] [sign]digits[ws]

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

Element Popis
ws Volitelné prázdné znaky.
znaménko 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 společně s počátečním symbolem. Chcete-li explicitně definovat prvky stylu společně s informacemi o formátování specifické pro jazykovou verzi, které mohou být přítomny v s, použijte metodu Int32.TryParse(String, NumberStyles, IFormatProvider, Int32).

Parametr s se parsuje pomocí informací o formátování v objektu NumberFormatInfo inicializovaném pro aktuální jazykovou verzi systému. Další informace najdete v tématu CurrentInfo.

Toto přetížení metody TryParse interpretuje všechny číslice v parametru s jako desítkové číslice. Chcete-li parsovat řetězcovou reprezentaci šestnáctkového čísla, zavolejte Int32.TryParse(String, NumberStyles, IFormatProvider, Int32) přetížení.

Viz také

Platí pro

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Int32)

Zdroj:
Int32.cs
Zdroj:
Int32.cs

Pokusí se analyzovat rozsah znaků UTF-8 do hodnoty.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result) = IUtf8SpanParsable<int>::TryParse;
public static bool TryParse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, out int result);
static member TryParse : ReadOnlySpan<byte> * IFormatProvider * int -> bool
Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider, ByRef result As Integer) As Boolean

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.

result
Int32

Při vrácení obsahuje výsledek úspěšné analýzy utf8Text nebo nedefinovanou hodnotu při selhání.

Návraty

true, pokud se utf8Text úspěšně parsoval; jinak false.

Platí pro

TryParse(ReadOnlySpan<Char>, IFormatProvider, Int32)

Zdroj:
Int32.cs
Zdroj:
Int32.cs
Zdroj:
Int32.cs

Pokusí se analyzovat rozsah znaků do hodnoty.

public:
 static bool TryParse(ReadOnlySpan<char> s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result) = ISpanParsable<int>::TryParse;
public static bool TryParse (ReadOnlySpan<char> s, IFormatProvider? provider, out int result);
static member TryParse : ReadOnlySpan<char> * IFormatProvider * int -> bool
Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As Integer) As Boolean

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.

result
Int32

Pokud tato metoda vrátí, obsahuje výsledek úspěšné analýzy s, nebo nedefinovanou hodnotu při selhání.

Návraty

true, pokud se s úspěšně parsoval; jinak false.

Platí pro

TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Int32)

Zdroj:
Int32.cs
Zdroj:
Int32.cs

Pokusí se analyzovat rozsah znaků UTF-8 do hodnoty.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result) = System::Numerics::INumberBase<int>::TryParse;
public static bool TryParse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style, IFormatProvider? provider, out int result);
static member TryParse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider * int -> bool
Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), style As NumberStyles, provider As IFormatProvider, ByRef result As Integer) As Boolean

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.

result
Int32

Při vrácení obsahuje výsledek úspěšné analýzy utf8Text nebo nedefinovanou hodnotu při selhání.

Návraty

true, pokud se utf8Text úspěšně parsoval; jinak false.

Platí pro

TryParse(ReadOnlySpan<Byte>, Int32)

Zdroj:
Int32.cs
Zdroj:
Int32.cs

Pokusí se převést rozsah znaků UTF-8 obsahující řetězcovou reprezentaci čísla na jeho 32bitové celé číslo se znaménkem.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, [Runtime::InteropServices::Out] int % result);
public static bool TryParse (ReadOnlySpan<byte> utf8Text, out int result);
static member TryParse : ReadOnlySpan<byte> * int -> bool
Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), ByRef result As Integer) As Boolean

Parametry

utf8Text
ReadOnlySpan<Byte>

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

result
Int32

Pokud tato metoda vrátí, obsahuje 32bitovou celočíselnou hodnotu odpovídající číslu obsaženému v utf8Text pokud převod proběhl úspěšně, nebo nula v případě selhání převodu. Tento parametr je předán neinicializovaný; jakákoli hodnota původně zadaná ve výsledku se přepíše.

Návraty

true, pokud byl utf8Text úspěšně převeden; jinak false.

Platí pro

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int32)

Zdroj:
Int32.cs
Zdroj:
Int32.cs
Zdroj:
Int32.cs

Převede reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselnou ekvivalent. Vrácená hodnota označuje, zda byl převod úspěšný.

public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result);
public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result) = System::Numerics::INumberBase<int>::TryParse;
public static bool TryParse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider? provider, out int result);
public static bool TryParse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider provider, out int result);
static member TryParse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider * int -> bool
Public Shared Function TryParse (s As ReadOnlySpan(Of Char), style As NumberStyles, provider As IFormatProvider, ByRef result As Integer) As Boolean

Parametry

s
ReadOnlySpan<Char>

Rozsah obsahující znaky, které představují číslo k převodu. Rozsah se interpretuje pomocí stylu určeného style.

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

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

result
Int32

Pokud tato metoda vrátí, obsahuje 32bitové signed celé číslo ekvivalentní číslo obsažené v s, pokud převod byl úspěšný, nebo nula v případě selhání převodu. Převod selže, pokud je parametr snull nebo Empty, není ve formátu kompatibilním s stylenebo představuje číslo menší než Int32.MinValue nebo větší než Int32.MaxValue. Tento parametr je předán neinicializovaný; všechny hodnoty původně zadané v result budou přepsány.

Návraty

true, pokud byl s úspěšně převeden; jinak false.

Platí pro

TryParse(String, NumberStyles, IFormatProvider, Int32)

Zdroj:
Int32.cs
Zdroj:
Int32.cs
Zdroj:
Int32.cs

Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na 32bitové celé číslo se znaky. Vrácená hodnota označuje, zda byl převod úspěšný.

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result);
public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result) = System::Numerics::INumberBase<int>::TryParse;
public static bool TryParse (string s, System.Globalization.NumberStyles style, IFormatProvider provider, out int result);
public static bool TryParse (string? s, System.Globalization.NumberStyles style, IFormatProvider? provider, out int result);
static member TryParse : string * System.Globalization.NumberStyles * IFormatProvider * int -> bool
Public Shared Function TryParse (s As String, style As NumberStyles, provider As IFormatProvider, ByRef result As Integer) As Boolean

Parametry

s
String

Řetězec obsahující číslo, které chcete převést. Řetězec se interpretuje pomocí stylu určeného style.

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

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

result
Int32

Pokud tato metoda vrátí, obsahuje 32bitové signed celé číslo ekvivalentní číslo obsažené v s, pokud převod byl úspěšný, nebo nula v případě selhání převodu. Převod selže, pokud je parametr snull nebo Empty, není ve formátu kompatibilním s stylenebo představuje číslo menší než Int32.MinValue nebo větší než Int32.MaxValue. Tento parametr je předán neinicializovaný; všechny hodnoty původně zadané v result budou přepsány.

Návraty

true, pokud byl s úspěšně převeden; jinak false.

Výjimky

style není NumberStyles hodnota.

-nebo-

style není kombinací hodnot AllowHexSpecifier a HexNumber.

Příklady

Následující příklad volá metodu Int32.TryParse(String, NumberStyles, IFormatProvider, Int32) s řadou různých řetězců a NumberStyles hodnot.

using namespace System;
using namespace System::Globalization;

void CallTryParse(String^ stringToConvert, NumberStyles styles)
{
      Int32 number;
      CultureInfo^ provider;

      // If currency symbol is allowed, use en-US culture. 
      if (((Int32) (styles & NumberStyles::AllowCurrencySymbol)) > 0)
         provider = gcnew CultureInfo("en-US");
      else
         provider = CultureInfo::InvariantCulture;

      bool result = Int32::TryParse(stringToConvert, styles, 
                                   provider, number);
      if (result)
         Console::WriteLine("Converted '{0}' to {1}.", stringToConvert, number);
      else
         Console::WriteLine("Attempted conversion of '{0}' failed.", 
                           Convert::ToString(stringToConvert));
}

void main()
{
      String^ numericString;
      NumberStyles styles;

      numericString = "106779";
      styles = NumberStyles::Integer;
      CallTryParse(numericString, styles);

      numericString = "-30677";
      styles = NumberStyles::None;
      CallTryParse(numericString, styles);

      styles = NumberStyles::AllowLeadingSign;
      CallTryParse(numericString, styles);

      numericString = "301677-";
      CallTryParse(numericString, styles);

      styles = styles | NumberStyles::AllowTrailingSign;
      CallTryParse(numericString, styles);

      numericString = "$10634";
      styles = NumberStyles::Integer;
      CallTryParse(numericString, styles);

      styles = NumberStyles::Integer | NumberStyles::AllowCurrencySymbol;
      CallTryParse(numericString, styles);

      numericString = "10345.00";
      styles = NumberStyles::Integer | NumberStyles::AllowDecimalPoint;
      CallTryParse(numericString, styles);

      numericString = "10345.72";
      styles = NumberStyles::Integer | NumberStyles::AllowDecimalPoint;
      CallTryParse(numericString, styles);

      numericString = "22,593"; 
      styles = NumberStyles::Integer | NumberStyles::AllowThousands;
      CallTryParse(numericString, styles);

      numericString = "12E-01";
      styles = NumberStyles::Integer | NumberStyles::AllowExponent;
      CallTryParse(numericString, styles); 

      numericString = "12E03";
      CallTryParse(numericString, styles); 

      numericString = "80c1";
      CallTryParse(numericString, NumberStyles::HexNumber);

      numericString = "0x80C1";
      CallTryParse(numericString, NumberStyles::HexNumber);      
      Console::ReadLine();
}
// The example displays the following output:
//      Converted '106779' to 106779.
//      Attempted conversion of '-30677' failed.
//      Converted '-30677' to -30677.
//      Attempted conversion of '301677-' failed.
//      Converted '301677-' to -301677.
//      Attempted conversion of '$10634' failed.
//      Converted '$10634' to 10634.
//      Converted '10345.00' to 10345.
//      Attempted conversion of '10345.72' failed.
//      Converted '22,593' to 22593.
//      Attempted conversion of '12E-01' failed.
//      Converted '12E03' to 12000.
//      Converted '80c1' to 32961.
//      Attempted conversion of '0x80C1' failed.
using System;
using System.Globalization;

public class StringParsing
{
   public static void Main()
   {
      string numericString;
      NumberStyles styles;

      numericString = "106779";
      styles = NumberStyles.Integer;
      CallTryParse(numericString, styles);

      numericString = "-30677";
      styles = NumberStyles.None;
      CallTryParse(numericString, styles);

      styles = NumberStyles.AllowLeadingSign;
      CallTryParse(numericString, styles);

      numericString = "301677-";
      CallTryParse(numericString, styles);

      styles = styles | NumberStyles.AllowTrailingSign;
      CallTryParse(numericString, styles);

      numericString = "$10634";
      styles = NumberStyles.Integer;
      CallTryParse(numericString, styles);

      styles = NumberStyles.Integer | NumberStyles.AllowCurrencySymbol;
      CallTryParse(numericString, styles);

      numericString = "10345.00";
      styles = NumberStyles.Integer | NumberStyles.AllowDecimalPoint;
      CallTryParse(numericString, styles);

      numericString = "10345.72";
      styles = NumberStyles.Integer | NumberStyles.AllowDecimalPoint;
      CallTryParse(numericString, styles);

      numericString = "22,593";
      styles = NumberStyles.Integer | NumberStyles.AllowThousands;
      CallTryParse(numericString, styles);

      numericString = "12E-01";
      styles = NumberStyles.Integer | NumberStyles.AllowExponent;
      CallTryParse(numericString, styles);

      numericString = "12E03";
      CallTryParse(numericString, styles);

      numericString = "80c1";
      CallTryParse(numericString, NumberStyles.HexNumber);

      numericString = "0x80C1";
      CallTryParse(numericString, NumberStyles.HexNumber);
   }

   private static void CallTryParse(string stringToConvert, NumberStyles styles)
   {
      CultureInfo provider;

      // If currency symbol is allowed, use en-US culture.
      if ((styles & NumberStyles.AllowCurrencySymbol) > 0)
         provider = new CultureInfo("en-US");
      else
         provider = CultureInfo.InvariantCulture;

      bool success = int.TryParse(stringToConvert, styles,
                                   provider, out int number);
      if (success)
         Console.WriteLine($"Converted '{stringToConvert}' to {number}.");
      else
         Console.WriteLine($"Attempted conversion of '{stringToConvert}' failed.");
   }
}
// The example displays the following output to the console:
//       Converted '106779' to 106779.
//       Attempted conversion of '-30677' failed.
//       Converted '-30677' to -30677.
//       Attempted conversion of '301677-' failed.
//       Converted '301677-' to -301677.
//       Attempted conversion of '$10634' failed.
//       Converted '$10634' to 10634.
//       Converted '10345.00' to 10345.
//       Attempted conversion of '10345.72' failed.
//       Converted '22,593' to 22593.
//       Attempted conversion of '12E-01' failed.
//       Converted '12E03' to 12000.
//       Converted '80c1' to 32961.
//       Attempted conversion of '0x80C1' failed.
open System
open System.Globalization

let callTryParse (stringToConvert: string) styles =
    let provider =
        // If currency symbol is allowed, use en-US culture.
        if int (styles &&& NumberStyles.AllowCurrencySymbol) > 0 then
            CultureInfo "en-US"
        else
            CultureInfo.InvariantCulture

    match Int32.TryParse(stringToConvert, styles, provider) with
    | true, number ->
        printfn $"Converted '{stringToConvert}' to {number}."
    | _ ->
        printfn $"Attempted conversion of '{stringToConvert}' failed."

[<EntryPoint>]
let main _ =
    let numericString = "106779"
    let styles = NumberStyles.Integer
    callTryParse numericString styles

    let numericString = "-30677"
    let styles = NumberStyles.None
    callTryParse numericString styles

    let styles = NumberStyles.AllowLeadingSign
    callTryParse numericString styles

    let numericString = "301677-"
    callTryParse numericString styles

    let styles = styles ||| NumberStyles.AllowTrailingSign
    callTryParse numericString styles

    let numericString = "$10634"
    let styles = NumberStyles.Integer
    callTryParse numericString styles

    let styles = NumberStyles.Integer ||| NumberStyles.AllowCurrencySymbol
    callTryParse numericString styles

    let numericString = "10345.00"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint
    callTryParse numericString styles

    let numericString = "10345.72"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint
    callTryParse numericString styles

    let numericString = "22,593"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowThousands
    callTryParse numericString styles

    let numericString = "12E-01"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowExponent
    callTryParse numericString styles

    let numericString = "12E03"
    callTryParse numericString styles

    let numericString = "80c1"
    callTryParse numericString NumberStyles.HexNumber

    let numericString = "0x80C1"
    callTryParse numericString NumberStyles.HexNumber

    0

// The example displays the following output to the console:
//       Converted '106779' to 106779.
//       Attempted conversion of '-30677' failed.
//       Converted '-30677' to -30677.
//       Attempted conversion of '301677-' failed.
//       Converted '301677-' to -301677.
//       Attempted conversion of '$10634' failed.
//       Converted '$10634' to 10634.
//       Converted '10345.00' to 10345.
//       Attempted conversion of '10345.72' failed.
//       Converted '22,593' to 22593.
//       Attempted conversion of '12E-01' failed.
//       Converted '12E03' to 12000.
//       Converted '80c1' to 32961.
//       Attempted conversion of '0x80C1' failed.
Imports System.Globalization

Module StringParsing
   Public Sub Main()
      Dim numericString As String
      Dim styles As NumberStyles
      
      numericString = "106779"
      styles = NumberStyles.Integer
      CallTryParse(numericString, styles)
      
      numericString = "-30677"
      styles = NumberStyles.None
      CallTryParse(numericString, styles)
      
      styles = NumberStyles.AllowLeadingSign
      CallTryParse(numericString, styles)
      
      numericString = "301677-"
      CallTryParse(numericString, styles)
      
      styles = styles Or NumberStyles.AllowTrailingSign
      CallTryParse(numericString, styles)
      
      numericString = "$10634"
      styles = NumberStyles.Integer
      CallTryParse(numericString, styles)
      
      styles = NumberStyles.Integer Or NumberStyles.AllowCurrencySymbol
      CallTryParse(numericString, styles)

      numericString = "10345.00"
      styles = NumberStyles.Integer Or NumberStyles.AllowDecimalPoint
      CallTryParse(numericString, styles)
      
      numericString = "10345.72"
      styles = NumberStyles.Integer Or NumberStyles.AllowDecimalPoint
      CallTryParse(numericString, styles)

      numericString = "22,593" 
      styles = NumberStyles.Integer Or NumberStyles.AllowThousands
      CallTryParse(numericString, styles)
      
      numericString = "12E-01"
      styles = NumberStyles.Integer Or NumberStyles.AllowExponent
      CallTryParse(numericString, styles) 
          
      numericString = "12E03"
      CallTryParse(numericString, styles) 
      
      numericString = "80c1"
      CallTryParse(numericString, NumberStyles.HexNumber)
      
      numericString = "0x80C1"
      CallTryParse(numericString, NumberStyles.HexNumber)
   End Sub
   
   Private Sub CallTryParse(stringToConvert As String, styles AS NumberStyles)
      Dim number As Integer
      Dim provider As CultureInfo
      
      ' If currency symbol is allowed, use en-US culture.
      If CBool(styles And NumberStyles.AllowCurrencySymbol) Then
         provider = CultureInfo.CurrentCulture
      Else
         provider = New CultureInfo("en-US")
      End If
      
      Dim result As Boolean = Int32.TryParse(stringToConvert, styles, _
                                             provider, number)
      If result Then
         Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, number)
      Else
         Console.WriteLine("Attempted conversion of '{0}' failed.", _
                           Convert.ToString(stringToConvert))
      End If                                                                           
   End Sub
End Module
' The example displays the following output to the console:
'       Converted '106779' to 106779.
'       Attempted conversion of '-30677' failed.
'       Converted '-30677' to -30677.
'       Attempted conversion of '301677-' failed.
'       Converted '301677-' to -301677.
'       Attempted conversion of '$10634' failed.
'       Converted '$10634' to 10634.
'       Converted '10345.00' to 10345.
'       Attempted conversion of '10345.72' failed.
'       Converted '22,593' to 22593.
'       Attempted conversion of '12E-01' failed.
'       Converted '12E03' to 12000.
'       Converted '80c1' to 32961.
'       Attempted conversion of '0x80C1' failed.

Poznámky

Metoda TryParse je podobná metodě Parse, s výjimkou TryParse metoda nevyvolá výjimku, pokud převod selže. Eliminuje potřebu použití zpracování výjimek k otestování FormatException v případě, že s je neplatný a nelze jej úspěšně analyzovat.

Parametr style definuje prvky stylu (například prázdné znaky nebo kladné nebo záporné znaménko), které jsou povoleny 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]digits][ws]

Nebo pokud parametr style obsahuje AllowHexSpecifier:

[ws]hexdigits[ws]

Položky 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 nebo 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 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. Symbol znaménka se může zobrazit v s, pokud style obsahuje příznaky NumberStyles.AllowLeadingSign nebo NumberStyles.AllowTrailingSign.
číslice Posloupnost číslic od 0 do 9.
, Oddělovač 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.
fractional_digits Jeden nebo více výskytů číslice 0. Desetinná číslice se můžou v s zobrazovat jenom v případě, že style obsahuje příznak NumberStyles.AllowDecimalPoint.
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á příznaku NumberStyles.None) se vždy úspěšně parsuje. 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 prvky fractional_digits. Nicméně, fractional_digits se musí skládat pouze z jedné nebo více 0 číslic nebo metoda vrací false.
NumberStyles.AllowExponent Parametr s může také použít exponenciální zápis. Pokud s představuje číslo v exponenciálním zápisu, musí představovat celé číslo v rozsahu Int32 datového typu bez nenulové desetinné komponenty.
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 $.
NumberStyles.Currency Všechny prvky. Parametr s nemůže představovat šestnáctkové číslo nebo číslo v exponenciálním zápisu.
NumberStyles.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.
NumberStyles.Number Prvky ws, znaménko, oddělovač tisíců (,) a desetinná čárka (.).
NumberStyles.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é mohou být přítomné v style, jsou NumberStyles.AllowLeadingWhite a NumberStyles.AllowTrailingWhite. (Výčet NumberStyles má složený styl, NumberStyles.HexNumber, který obsahuje oba příznaky prázdných znaků.)

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

Viz také

Platí pro