Int32.Parse Metod

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

public:
 static int Parse(System::String ^ s);

public static int Parse(string s);

static member Parse : string -> int

Public Shared Function Parse (s As String) As Integer

Parametrar

Returer

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

Undantag

Exempel

I följande exempel visas hur du konverterar ett strängvärde till ett 32-bitars signerat heltalsvärde med hjälp av Int32.Parse(String) metoden. Det resulterande heltalsvärdet visas sedan för konsolen.

using System;

public class Example
{
   public static void Main()
   {
      string[] values = { "+13230", "-0", "1,390,146", "$190,235,421,127",
                          "0xFA1B", "163042", "-10", "007", "2147483647",
                          "2147483648", "16e07", "134985.0", "-12034",
                          "-2147483648", "-2147483649" };
      foreach (string value in values)
      {
         try {
            int number = Int32.Parse(value);
            Console.WriteLine("{0} --> {1}", value, number);
         }
         catch (FormatException) {
            Console.WriteLine("{0}: Bad Format", value);
         }
         catch (OverflowException) {
            Console.WriteLine("{0}: Overflow", value);
         }
      }
   }
}
// The example displays the following output:
//       +13230 --> 13230
//       -0 --> 0
//       1,390,146: Bad Format
//       $190,235,421,127: Bad Format
//       0xFA1B: Bad Format
//       163042 --> 163042
//       -10 --> -10
//       007 --> 7
//       2147483647 --> 2147483647
//       2147483648: Overflow
//       16e07: Bad Format
//       134985.0: Bad Format
//       -12034 --> -12034
//       -2147483648 --> -2147483648
//       -2147483649: Overflow

open System

let values =
    [ "+13230"; "-0"; "1,390,146"; "$190,235,421,127"
      "0xFA1B"; "163042"; "-10"; "007"; "2147483647"
      "2147483648"; "16e07"; "134985.0"; "-12034"
      "-2147483648"; "-2147483649" ]

for value in values do
    try
        let number = Int32.Parse value
        printfn $"{value} --> {number}"
    with 
    | :? FormatException ->
        printfn $"{value}: Bad Format"
    | :? OverflowException ->
        printfn $"{value}: Overflow"
    

// The example displays the following output:
//       +13230 --> 13230
//       -0 --> 0
//       1,390,146: Bad Format
//       $190,235,421,127: Bad Format
//       0xFA1B: Bad Format
//       163042 --> 163042
//       -10 --> -10
//       007 --> 7
//       2147483647 --> 2147483647
//       2147483648: Overflow
//       16e07: Bad Format
//       134985.0: Bad Format
//       -12034 --> -12034
//       -2147483648 --> -2147483648
//       -2147483649: Overflow

Module Example
   Public Sub Main()
      Dim values() As String = { "+13230", "-0", "1,390,146", "$190,235,421,127",
                                 "0xFA1B", "163042", "-10", "007", "2147483647", 
                                 "2147483648", "16e07", "134985.0", "-12034",
                                 "-2147483648", "-2147483649"  }
      For Each value As String In values
         Try
            Dim number As Integer = Int32.Parse(value) 
            Console.WriteLine("{0} --> {1}", value, number)
         Catch e As FormatException
            Console.WriteLine("{0}: Bad Format", value)
         Catch e As OverflowException
            Console.WriteLine("{0}: Overflow", value)   
         End Try  
      Next
   End Sub
End Module
' The example displays the following output:
'       +13230 --> 13230
'       -0 --> 0
'       1,390,146: Bad Format
'       $190,235,421,127: Bad Format
'       0xFA1B: Bad Format
'       163042 --> 163042
'       -10 --> -10
'       007 --> 7
'       2147483647 --> 2147483647
'       2147483648: Overflow
'       16e07: Bad Format
'       134985.0: Bad Format
'       -12034 --> -12034
'       -2147483648 --> -2147483648
'       -2147483649: Overflow

Kommentarer

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

[ws][sign]digits[ws]

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

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

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

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

Se även

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

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

public:
 static int Parse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider) = IUtf8SpanParsable<int>::Parse;

public static int Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider);

static member Parse : ReadOnlySpan<byte> * IFormatProvider -> int

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider) As Integer

Parametrar

Returer

Resultatet av parsning utf8Text.

Implementeringar

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

public:
 static int Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<int>::Parse;

public static int Parse(ReadOnlySpan<char> s, IFormatProvider? provider);

static member Parse : ReadOnlySpan<char> * IFormatProvider -> int

Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As Integer

Parametrar

Returer

Resultatet av parsning s.

Implementeringar

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

public:
 static int Parse(System::String ^ s, System::Globalization::NumberStyles style);

public static int Parse(string s, System.Globalization.NumberStyles style);

static member Parse : string * System.Globalization.NumberStyles -> int

Public Shared Function Parse (s As String, style As NumberStyles) As Integer

Parametrar

Returer

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

Undantag

Exempel

I följande exempel används Int32.Parse(String, NumberStyles) metoden för att parsa strängrepresentationerna av flera Int32 värden. Den aktuella kulturen för exemplet är en-US.

using System;
using System.Globalization;

public class ParseInt32
{
   public static void Main()
   {
      Convert("104.0", NumberStyles.AllowDecimalPoint);
      Convert("104.9", NumberStyles.AllowDecimalPoint);
      Convert(" $17,198,064.42", NumberStyles.AllowCurrencySymbol |
                                 NumberStyles.Number);
      Convert("103E06", NumberStyles.AllowExponent);
      Convert("-1,345,791", NumberStyles.AllowThousands);
      Convert("(1,345,791)", NumberStyles.AllowThousands |
                             NumberStyles.AllowParentheses);
   }

   private static void Convert(string value, NumberStyles style)
   {
      try
      {
         int number = Int32.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 Int32 type.", value);
      }
   }
}
// The example displays the following output to the console:
//       Converted '104.0' to 104.
//       '104.9' is out of range of the Int32 type.
//       ' $17,198,064.42' is out of range of the Int32 type.
//       Converted '103E06' to 103000000.
//       Unable to convert '-1,345,791'.
//       Converted '(1,345,791)' to -1345791.

open System
open System.Globalization

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

convert "104.0" NumberStyles.AllowDecimalPoint
convert "104.9" NumberStyles.AllowDecimalPoint
convert " $17,198,064.42" (NumberStyles.AllowCurrencySymbol ||| NumberStyles.Number)
convert "103E06" NumberStyles.AllowExponent
convert "-1,345,791" NumberStyles.AllowThousands
convert "(1,345,791)" (NumberStyles.AllowThousands ||| NumberStyles.AllowParentheses)


// The example displays the following output to the console:
//       Converted '104.0' to 104.
//       '104.9' is out of range of the Int32 type.
//       ' $17,198,064.42' is out of range of the Int32 type.
//       Converted '103E06' to 103000000.
//       Unable to convert '-1,345,791'.
//       Converted '(1,345,791)' to -1345791.

Imports System.Globalization

Module ParseInt32
   Public Sub Main()
      Convert("104.0", NumberStyles.AllowDecimalPoint)    
      Convert("104.9", NumberStyles.AllowDecimalPoint)
      Convert(" $17,198,064.42", NumberStyles.AllowCurrencySymbol Or _
                                 NumberStyles.Number)
      Convert("103E06", NumberStyles.AllowExponent)  
      Convert("-1,345,791", NumberStyles.AllowThousands)
      Convert("(1,345,791)", NumberStyles.AllowThousands Or _
                             NumberStyles.AllowParentheses)
   End Sub
   
   Private Sub Convert(value As String, style As NumberStyles)
      Try
         Dim number As Integer = Int32.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 Int32 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 Int32 type.
'       ' $17,198,064.42' is out of range of the Int32 type.
'       Converted '103E06' to 103000000.
'       Unable to convert '-1,345,791'.
'       Converted '(1,345,791)' to -1345791.

Kommentarer

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

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

Eller, om style inkluderar AllowHexSpecifier:

[ws]hexdigits[ws]

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

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

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

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

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

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

Se även

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

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

public:
 static int Parse(System::String ^ s, IFormatProvider ^ provider);

public:
 static int Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<int>::Parse;

public static int Parse(string s, IFormatProvider provider);

public static int Parse(string s, IFormatProvider? provider);

static member Parse : string * IFormatProvider -> int

Public Shared Function Parse (s As String, provider As IFormatProvider) As Integer

Parametrar

Returer

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

Implementeringar

Undantag

Exempel

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

protected void OkToInteger_Click(object sender, EventArgs e)
{
    string locale;
    int 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 = Int32.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 OkToInteger_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles OkToInteger.Click
    Dim locale As String
    Dim culture As CultureInfo
    Dim number As Integer

    ' 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 = Int32.Parse(Me.inputNumber.Text, culture.NumberFormat)
    Catch ex As FormatException
        Exit Sub
    Catch ex As Exception
        Exit Sub
    End Try

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

Kommentarer

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

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

[ws][sign]digits[ws]

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

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

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

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

Se även

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

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

public static int Parse(ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);

static member Parse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider -> int

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As Integer

Parametrar

Returer

Resultatet av parsning utf8Text.

Implementeringar

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

public static int Parse(ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);

public static int Parse(ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider provider = default);

static member Parse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider -> int

Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As Integer

Parametrar

Returer

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

Implementeringar

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

Källa:

Int32.cs

public:
 static int Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider);

public:
 static int Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<int>::Parse;

public static int Parse(string s, System.Globalization.NumberStyles style, IFormatProvider provider);

public static int Parse(string s, System.Globalization.NumberStyles style, IFormatProvider? provider);

static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> int

Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As Integer

Parametrar

Returer

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

Implementeringar

Undantag

Exempel

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

using System;
using System.Globalization;

public class ParseInt32
{
   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
      {
         int number = Int32.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 Int32 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 Int32 type.
//       Unable to convert '631,900'.
//       Converted '631,900' to 631900.

open System
open System.Globalization

let convert (value: string) (style: NumberStyles) (provider: IFormatProvider) =
    try
        let number = Int32.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 Int32 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 Int32 type.
//       Unable to convert '631,900'.
//       Converted '631,900' to 631900.

Imports System.Globalization

Module ParseInt32
   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 Integer = Int32.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 Int32 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 Int32 type.
'       Unable to convert '631,900'.
'       Converted '631,900' to 631900.

Kommentarer

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

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

Eller, om style inkluderar AllowHexSpecifier:

[ws]hexdigits[ws]

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

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

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

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

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

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

Se även

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