BigInteger.Parse Metod

Definition

Namnområde:

System.Numerics

Sammansättning:

System.Numerics.dll

Konverterar strängrepresentationen av ett tal till dess BigInteger motsvarighet.

Överlagringar

Name	Description
Parse(String)	Konverterar strängrepresentationen av ett tal till dess BigInteger motsvarighet.
Parse(String, NumberStyles)	Konverterar strängrepresentationen av ett tal i ett angivet format till dess BigInteger motsvarighet.
Parse(String, IFormatProvider)	Konverterar strängrepresentationen av ett tal i ett angivet kulturspecifikt format till dess BigInteger motsvarighet.
Parse(String, NumberStyles, IFormatProvider)	Konverterar strängrepresentationen av ett tal i ett angivet format och kulturspecifikt format till dess BigInteger motsvarighet.

Parse(String)

Konverterar strängrepresentationen av ett tal till dess BigInteger motsvarighet.

public:
 static System::Numerics::BigInteger Parse(System::String ^ value);

public static System.Numerics.BigInteger Parse(string value);

static member Parse : string -> System.Numerics.BigInteger

Public Shared Function Parse (value As String) As BigInteger

Parametrar

value

String

En sträng som innehåller talet som ska konverteras.

Returer

BigInteger

Ett värde som motsvarar det tal som anges i parametern value .

Undantag

ArgumentNullException

value är null.

FormatException

value är inte i rätt format.

Exempel

I följande exempel används Parse(String) metoden för att instansiera två BigInteger objekt. Det multiplicerar varje objekt med ett annat tal och anropar Compare sedan metoden för att fastställa relationen mellan de två värdena.

string stringToParse = String.Empty;
try
{
   // Parse two strings.
   string string1, string2;
   string1 = "12347534159895123";
   string2 = "987654321357159852";
   stringToParse = string1;
   BigInteger number1 = BigInteger.Parse(stringToParse);
   Console.WriteLine("Converted '{0}' to {1:N0}.", stringToParse, number1);
   stringToParse = string2;
   BigInteger number2 = BigInteger.Parse(stringToParse);
   Console.WriteLine("Converted '{0}' to {1:N0}.", stringToParse, number2);
   // Perform arithmetic operations on the two numbers.
   number1 *= 3;
   number2 *= 2;
   // Compare the numbers.
   int result = BigInteger.Compare(number1, number2);
   switch (result)
   {
      case -1:
         Console.WriteLine("{0} is greater than {1}.", number2, number1);
         break;
      case 0:
         Console.WriteLine("{0} is equal to {1}.", number1, number2);
         break;
      case 1:
         Console.WriteLine("{0} is greater than {1}.", number1, number2);
         break;
   }
}
catch (FormatException)
{
   Console.WriteLine("Unable to parse {0}.", stringToParse);
}
// The example displays the following output:
//    Converted '12347534159895123' to 12,347,534,159,895,123.
//    Converted '987654321357159852' to 987,654,321,357,159,852.
//    1975308642714319704 is greater than 37042602479685369.

    let mutable stringToParse = ""

    try
        // Parse two strings.
        let string1 = "12347534159895123"
        let string2 = "987654321357159852"
        stringToParse <- string1
        let number1 = BigInteger.Parse stringToParse
        printfn $"Converted '{stringToParse}' to {number1:N0}."
        stringToParse <- string2
        let number2 = BigInteger.Parse stringToParse
        printfn $"Converted '{stringToParse}' to {number2:N0}."
        // Perform arithmetic operations on the two numbers.
        let number1 = number1 * bigint 3
        let number2 = number2 * bigint 2
        // Compare the numbers.
        let result = BigInteger.Compare(number1, number2)

        match result with
        | -1 -> printfn $"{number2:N0} is greater than {number1:N0}."
        | 0 -> printfn $"{number1:N0} is equal to {number2:N0}."
        | 1
        | _ -> printfn $"{number1:N0} is greater than {number2:N0}."
    with :? FormatException ->
        printfn $"Unable to parse {stringToParse}."

// The example displays the following output:
//    Converted '12347534159895123' to 12,347,534,159,895,123.
//    Converted '987654321357159852' to 987,654,321,357,159,852.
//    1975308642714319704 is greater than 37042602479685369.

Dim stringToParse As String = String.Empty
Try
   ' Parse two strings.
   Dim string1, string2 As String
   string1 = "12347534159895123"
   string2 = "987654321357159852"
   stringToParse = string1
   Dim number1 As BigInteger = BigInteger.Parse(stringToParse)
   Console.WriteLine("Converted '{0}' to {1:N0}.", stringToParse, number1)
   stringToParse = string2
   Dim number2 As BigInteger = BigInteger.Parse(stringToParse)
   Console.WriteLine("Converted '{0}' to {1:N0}.", stringToParse, number2)
   ' Perform arithmetic operations on the two numbers.
   number1 *= 3
   number2 *= 2
   ' Compare the numbers.
   Select Case BigInteger.Compare(number1, number2)
      Case -1
         Console.WriteLine("{0} is greater than {1}.", number2, number1)
      Case 0
         Console.WriteLine("{0} is equal to {1}.", number1, number2)
      Case 1
         Console.WriteLine("{0} is greater than {1}.", number1, number2)
   End Select      
Catch e As FormatException
   Console.WriteLine("Unable to parse {0}.", stringToParse)
End Try
' The example displays the following output:
'    Converted '12347534159895123' to 12,347,534,159,895,123.
'    Converted '987654321357159852' to 987,654,321,357,159,852.
'    1975308642714319704 is greater than 37042602479685369.

Kommentarer

Parametern value ska vara strängrepresentationen av ett tal i följande formulär.

[ws][sign]digits[ws]

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

Element	Description
Ws	Valfritt blanksteg.
signera	Ett valfritt tecken. Giltiga teckentecken bestäms av NumberFormatInfo.NegativeSign egenskaperna och NumberFormatInfo.PositiveSign för den aktuella kulturen.
Siffror	En sekvens med siffror mellan 0 och 9. Inledande nollor ignoreras.

Note

Strängen som anges av parametern value tolkas med hjälp NumberStyles.Integer av formatet . Den får inte innehålla några gruppavgränsare eller decimaltecken och får inte ha en decimaldel.

Parametern value parsas med hjälp av formateringsinformationen i ett System.Globalization.NumberFormatInfo objekt som initieras för den aktuella systemkulturen. Mer information finns i NumberFormatInfo.CurrentInfo. Använd metoden för att parsa en sträng med hjälp av formateringsinformationen Parse(String, IFormatProvider) för en viss kultur.

Important

Om du använder Parse metoden för att avrunda strängrepresentationen av ett BigInteger värde som utdata från ToString metoden, bör du använda BigInteger.ToString(String) metoden med formatspecificeraren "R" för att generera strängrepresentationen BigInteger av värdet. Annars bevarar strängrepresentationen BigInteger endast de 50 viktigaste siffrorna i det ursprungliga värdet och data kan gå förlorade när du använder Parse metoden för att återställa BigInteger värdet.

Se även

• TryParse

Parse(String, NumberStyles)

Konverterar strängrepresentationen av ett tal i ett angivet format till dess BigInteger motsvarighet.

public:
 static System::Numerics::BigInteger Parse(System::String ^ value, System::Globalization::NumberStyles style);

public static System.Numerics.BigInteger Parse(string value, System.Globalization.NumberStyles style);

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

Public Shared Function Parse (value As String, style As NumberStyles) As BigInteger

Parametrar

value

String

En sträng som innehåller ett tal som ska konverteras.

style

NumberStyles

En bitvis kombination av uppräkningsvärdena som anger det tillåtna formatet för value.

Returer

BigInteger

Ett värde som motsvarar det tal som anges i parametern value .

Undantag

ArgumentException

style är inte ett NumberStyles värde.

-eller-

style AllowHexSpecifier innehåller flaggan eller HexNumber tillsammans med ett annat värde.

ArgumentNullException

value är null.

FormatException

value uppfyller inte det indatamönster som anges av NumberStyles.

Exempel

I följande exempel visas anrop till Parse(String, NumberStyles) metoden med flera möjliga värden för parametern style . Den visar hur du tolkar en sträng som ett hexadecimalt värde och hur du inte tillåter blanksteg och teckensymboler.

BigInteger number;
// Method should succeed (white space and sign allowed)
number = BigInteger.Parse("   -68054   ", NumberStyles.Integer);
Console.WriteLine(number);
// Method should succeed (string interpreted as hexadecimal)
number = BigInteger.Parse("68054", NumberStyles.AllowHexSpecifier);
Console.WriteLine(number);
// Method call should fail: sign not allowed
try
{
   number = BigInteger.Parse("   -68054  ", NumberStyles.AllowLeadingWhite
                                            | NumberStyles.AllowTrailingWhite);
   Console.WriteLine(number);
}
catch (FormatException e)
{
   Console.WriteLine(e.Message);
}
// Method call should fail: white space not allowed
try
{
   number = BigInteger.Parse("   68054  ", NumberStyles.AllowLeadingSign);
   Console.WriteLine(number);
}
catch (FormatException e)
{
   Console.WriteLine(e.Message);
}
//
// The method produces the following output:
//
//     -68054
//     426068
//     Input string was not in a correct format.
//     Input string was not in a correct format.

    let number = BigInteger.Parse("   -68054   ", NumberStyles.Integer)
    printfn $"{number}"
    let number = BigInteger.Parse("68054", NumberStyles.AllowHexSpecifier)
    printfn $"{number}"

    try
        let number =
            BigInteger.Parse("   -68054  ", NumberStyles.AllowLeadingWhite ||| NumberStyles.AllowTrailingWhite)

        printfn $"{number}"
    with :? FormatException as e ->
        printfn $"{e.Message}"

    try
        let number = BigInteger.Parse("   68054  ", NumberStyles.AllowLeadingSign)
        printfn $"{number}"
    with :? FormatException as e ->
        printfn $"{e.Message}"
// The method produces the following output:
//     -68054
//     426068
//     Input string was not in a correct format.
//     Input string was not in a correct format.

Dim number As BigInteger 
' Method should succeed (white space and sign allowed)
number = BigInteger.Parse("   -68054   ", NumberStyles.Integer)
Console.WriteLine(number)
' Method should succeed (string interpreted as hexadecimal)
number = BigInteger.Parse("68054", NumberStyles.AllowHexSpecifier)
Console.WriteLine(number)
' Method call should fail: sign not allowed
Try
   number = BigInteger.Parse("   -68054  ", NumberStyles.AllowLeadingWhite _
                                            Or NumberStyles.AllowTrailingWhite)
   Console.WriteLine(number)
Catch e As FormatException
   Console.WriteLine(e.Message)
End Try                                                     
' Method call should fail: white space not allowed
Try
   number = BigInteger.Parse("   68054  ", NumberStyles.AllowLeadingSign)
   Console.WriteLine(number)
Catch e As FormatException
   Console.WriteLine(e.Message)
End Try    
'
' The method produces the following output:
'
'     -68054
'     426068
'     Input string was not in a correct format.
'     Input string was not in a correct format.

Kommentarer

Parametern style definierar formatelementen (till exempel blanksteg, symbolen för positiva eller negativa tecken, gruppavgränsningssymbolen eller decimaltecknet) som tillåts i parametern value för att parsningsåtgärden ska lyckas. styles måste vara en kombination av bitflaggor från NumberStyles uppräkningen. Parametern style gör den här metoden användbar när value den innehåller strängrepresentationen av ett hexadecimalt värde, när talsystemet (decimal eller hexadecimalt) som representeras av value endast är känt vid körning, eller när du vill neka tomt utrymme eller en teckensymbol i value.

Beroende på värdet för stylekan parametern value innehålla följande element:

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

Om style innehåller NumberStyles.AllowHexSpecifierkan parametern value innehålla följande element:

[ws]hexdigits[ws]

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

Element	Description
Ws	Valfritt blanksteg. Tomt utrymme kan visas i början av value om style innehåller NumberStyles.AllowLeadingWhite flaggan, och det kan visas i slutet av value 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 value om style den NumberStyles.AllowCurrencySymbol innehåller flaggan.
signera	Ett valfritt tecken. Tecknet kan visas i början av value om style innehåller NumberStyles.AllowLeadingSign flaggan, och det kan visas i slutet av value om style innehåller NumberStyles.AllowTrailingSign flaggan. Parenteser kan användas i value 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 gruppavgränsare. Den aktuella kulturens gruppavgränsare kan visas i value om style den NumberStyles.AllowThousands innehåller flaggan.
.	Ett kulturspecifikt decimaltecken. Den aktuella kulturens decimaltecken kan visas i value 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 FormatException .
E	Tecknet "e" eller "E", som anger att värdet representeras i exponentiell (vetenskaplig) notation. Parametern value 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.

Note

Alla avslutande NUL-tecken (U+0000) i s ignoreras av parsningsåtgärden, oavsett argumentets style värde.

En sträng med endast siffror (vilket motsvarar NumberStyles.None formatet) parsar alltid korrekt. De flesta av de återstående NumberStyles medlemmarna styr element som kan finnas, 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 value.

NumberStyles värde	Element som tillåts value utöver siffror
None	Endast elementet digits .
AllowDecimalPoint	Decimaltecknet (.) och bråksiffriga element.
AllowExponent	Tecknet "e" eller "E", som anger exponentiell notation, tillsammans med exponential_digits.
AllowLeadingWhite	WS-elementet i början av value.
AllowTrailingWhite	WS-elementet i slutet av value.
AllowLeadingSign	Teckenelementet i början av value.
AllowTrailingSign	Teckenelementet i slutet av value.
AllowParentheses	Teckenelementet i form av parenteser som omger det numeriska värdet.
AllowThousands	Gruppavgränsaren (,).
AllowCurrencySymbol	Valutaelementet ($).
Currency	Alla element. Kan dock value inte representera ett hexadecimalt tal eller ett tal i exponentiell notation.
Float	WS-elementet i början eller slutet av value, signerar i början av valueoch decimaltecknet (.). Parametern value kan också använda exponentiell notation.
Number	Elementen ws, sign, gruppavgränsare (,) och decimaltecken (.).
Any	Alla element. Kan dock value inte representera ett hexadecimalt tal.

Important

Om du använder Parse metoden för att avrunda strängrepresentationen av ett BigInteger värde som utdata från ToString metoden, bör du använda BigInteger.ToString(String) metoden med formatspecificeraren "R" för att generera strängrepresentationen BigInteger av värdet. Annars bevarar strängrepresentationen BigInteger endast de 50 viktigaste siffrorna i det ursprungliga värdet och data kan gå förlorade när du använder Parse metoden för att återställa BigInteger värdet.

Till skillnad från de andra NumberStyles värdena, som tillåter, men inte kräver, innebär förekomsten av vissa formatelement i value, NumberStyles.AllowHexSpecifier att de enskilda numeriska tecknen i value alltid tolkas som hexadecimala tecken. Giltiga hexadecimala tecken är 0-9, A-F och a-f. De enda andra flaggorna som kan kombineras med parametern style är NumberStyles.AllowLeadingWhite och NumberStyles.AllowTrailingWhite. (Uppräkningen NumberStyles innehåller ett sammansatt talformat, HexNumber, som innehåller båda blankstegsflaggor.)

Note

Om value är strängrepresentationen av ett hexadecimalt tal kan det inte föregås av någon dekoration (till exempel 0x eller &h) som särskiljer det som ett hexadecimalt tal. Detta gör att konverteringen misslyckas.

Om value är en hexadecimal sträng Parse(String, NumberStyles) tolkas value metoden som ett negativt tal som lagras med hjälp av två komplementrepresentation om de två första hexadecimala siffrorna är större än eller lika med 0x80. Med andra ord tolkar metoden den högsta biten av den första byteen i value som teckenbiten. För att säkerställa att en hexadecimal sträng tolkas korrekt som ett positivt tal måste den första siffran i value ha värdet noll. Metoden tolkas 0x80 till exempel som ett negativt värde, men den tolkar antingen 0x080 eller 0x0080 som ett positivt värde. I följande exempel visas skillnaden mellan hexadecimala strängar som representerar negativa och positiva värden.

using System;
using System.Globalization;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      string[] hexStrings = { "80", "E293", "F9A2FF", "FFFFFFFF",
                              "080", "0E293", "0F9A2FF", "0FFFFFFFF",
                              "0080", "00E293", "00F9A2FF", "00FFFFFFFF" };
      foreach (string hexString in hexStrings)
      {
         BigInteger number = BigInteger.Parse(hexString, NumberStyles.AllowHexSpecifier);
         Console.WriteLine("Converted 0x{0} to {1}.", hexString, number);
      }
   }
}
// The example displays the following output:
//       Converted 0x80 to -128.
//       Converted 0xE293 to -7533.
//       Converted 0xF9A2FF to -417025.
//       Converted 0xFFFFFFFF to -1.
//       Converted 0x080 to 128.
//       Converted 0x0E293 to 58003.
//       Converted 0x0F9A2FF to 16360191.
//       Converted 0x0FFFFFFFF to 4294967295.
//       Converted 0x0080 to 128.
//       Converted 0x00E293 to 58003.
//       Converted 0x00F9A2FF to 16360191.
//       Converted 0x00FFFFFFFF to 4294967295.

open System.Globalization
open System.Numerics

let hexStrings =
    [| "80"
       "E293"
       "F9A2FF"
       "FFFFFFFF"
       "080"
       "0E293"
       "0F9A2FF"
       "0FFFFFFFF"
       "0080"
       "00E293"
       "00F9A2FF"
       "00FFFFFFFF" |]

for hexString in hexStrings do
    let number = BigInteger.Parse(hexString, NumberStyles.AllowHexSpecifier)
    printfn $"Converted 0x{hexString} to {number:N0}."
// The example displays the following output:
//       Converted 0x80 to -128.
//       Converted 0xE293 to -7533.
//       Converted 0xF9A2FF to -417025.
//       Converted 0xFFFFFFFF to -1.
//       Converted 0x080 to 128.
//       Converted 0x0E293 to 58003.
//       Converted 0x0F9A2FF to 16360191.
//       Converted 0x0FFFFFFFF to 4294967295.
//       Converted 0x0080 to 128.
//       Converted 0x00E293 to 58003.
//       Converted 0x00F9A2FF to 16360191.
//       Converted 0x00FFFFFFFF to 4294967295.

Imports System.Globalization
Imports System.Numerics

Module Example
   Public Sub Main()
      Dim hexStrings() As String = { "80", "E293", "F9A2FF", "FFFFFFFF", 
                                     "080", "0E293", "0F9A2FF", "0FFFFFFFF",  
                                     "0080", "00E293", "00F9A2FF", "00FFFFFFFF" }
      For Each hexString As String In hexStrings
         Dim number As BigInteger = BigInteger.Parse(hexString, NumberStyles.AllowHexSpecifier)
         Console.WriteLine("Converted 0x{0} to {1}.", hexString, number)
      Next         
   End Sub
End Module
' The example displays the following output:
'       Converted 0x80 to -128.
'       Converted 0xE293 to -7533.
'       Converted 0xF9A2FF to -417025.
'       Converted 0xFFFFFFFF to -1.
'       Converted 0x080 to 128.
'       Converted 0x0E293 to 58003.
'       Converted 0x0F9A2FF to 16360191.
'       Converted 0x0FFFFFFFF to 4294967295.
'       Converted 0x0080 to 128.
'       Converted 0x00E293 to 58003.
'       Converted 0x00F9A2FF to 16360191.
'       Converted 0x00FFFFFFFF to 4294967295.

Parametern value parsas med hjälp av 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 Parse(String, NumberStyles, IFormatProvider) .

Se även

• TryParse

Parse(String, IFormatProvider)

Konverterar strängrepresentationen av ett tal i ett angivet kulturspecifikt format till dess BigInteger motsvarighet.

public:
 static System::Numerics::BigInteger Parse(System::String ^ value, IFormatProvider ^ provider);

public static System.Numerics.BigInteger Parse(string value, IFormatProvider provider);

static member Parse : string * IFormatProvider -> System.Numerics.BigInteger

Public Shared Function Parse (value As String, provider As IFormatProvider) As BigInteger

Parametrar

value

String

En sträng som innehåller ett tal som ska konverteras.

provider

IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om value.

Returer

BigInteger

Ett värde som motsvarar det tal som anges i parametern value .

Undantag

ArgumentNullException

value är null.

FormatException

value är inte i rätt format.

Exempel

I följande exempel visas två sätt att definiera tilde (~) som ett negativt tecken för formateringsvärden BigInteger . Observera att om du vill visa BigInteger värdena i samma format som de ursprungliga strängarna måste koden anropa BigInteger.ToString(IFormatProvider) metoden och skicka den till det NumberFormatInfo objekt som innehåller formateringsinformation.

Det första exemplet definierar en klass som implementerar IFormatProvider och använder GetFormat metoden för att returnera objektet NumberFormatInfo som innehåller formateringsinformation.

public class BigIntegerFormatProvider : IFormatProvider
{
   public object GetFormat(Type formatType)
   {
      if (formatType == typeof(NumberFormatInfo))
      {
         NumberFormatInfo numberFormat = new NumberFormatInfo();
         numberFormat.NegativeSign = "~";
         return numberFormat;
      }
      else
      {
         return null;
      }
   }
}

type BigIntegerFormatProvider() =
    interface IFormatProvider with

        member _.GetFormat(formatType: Type) =
            if formatType = typeof<NumberFormatInfo> then
                let numberFormat = NumberFormatInfo()
                numberFormat.NegativeSign <- "~"
                numberFormat
            else
                null

Public Class BigIntegerFormatProvider : Implements IFormatProvider
   Public Function GetFormat(formatType As Type) As Object _
                            Implements IFormatProvider.GetFormat
      If formatType Is GetType(NumberFormatInfo) Then
         Dim numberFormat As New NumberFormatInfo
         numberFormat.NegativeSign = "~"
         Return numberFormat
      Else
         Return Nothing
      End If      
   End Function
End Class

Ett BigInteger objekt kan sedan instansieras med följande kod:

BigInteger number = BigInteger.Parse("~6354129876", new BigIntegerFormatProvider());
// Display value using same formatting information
Console.WriteLine(number.ToString(new BigIntegerFormatProvider()));
// Display value using formatting of current culture
Console.WriteLine(number);

let number = BigInteger.Parse("~6354129876", BigIntegerFormatProvider())
printfn $"{number.ToString(BigIntegerFormatProvider())}"
printfn $"{number}"

Dim number As BigInteger = BigInteger.Parse("~6354129876", New BigIntegerFormatProvider)
' Display value using same formatting information
Console.WriteLine(number.ToString(New BigIntegerFormatProvider))
' Display value using formatting of current culture
Console.WriteLine(number)

Det andra exemplet är enklare. Det skickar objektet NumberFormatInfo som tillhandahåller formateringsinformation till parametern provider .

NumberFormatInfo fmt = new NumberFormatInfo();
fmt.NegativeSign = "~";

BigInteger number = BigInteger.Parse("~6354129876", fmt);
// Display value using same formatting information
Console.WriteLine(number.ToString(fmt));
// Display value using formatting of current culture
Console.WriteLine(number);

let fmt = NumberFormatInfo()
fmt.NegativeSign <- "~"

let number = BigInteger.Parse("~6354129876", fmt)
printfn $"{number.ToString fmt}"
printfn $"{number}"

Dim fmt As New NumberFormatInfo()
fmt.NegativeSign = "~"

Dim number As BigInteger = BigInteger.Parse("~6354129876", fmt)
' Display value using same formatting information
Console.WriteLine(number.ToString(fmt))
' Display value using formatting of current culture
Console.WriteLine(number)

Kommentarer

Parametern value ska vara strängrepresentationen av ett tal i följande formulär:

[ws][sign]digits[ws]

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

Element	Description
Ws	Valfritt blanksteg.
signera	Ett valfritt tecken. Giltiga teckentecken bestäms av NumberFormatInfo.NegativeSign egenskaperna och NumberFormatInfo.PositiveSign för objektet NumberFormatInfo som returneras av provider objektets GetFormat -metod.
Siffror	En sekvens med siffror mellan 0 och 9. Inledande nollor ignoreras.

Note

Strängen som anges av parametern value tolkas med formatet NumberStyles.Integer . Den får inte innehålla några gruppavgränsare eller decimaltecken och får inte ha en decimaldel.

Important

Om du använder Parse metoden för att avrunda strängrepresentationen av ett BigInteger värde som utdata från ToString metoden, bör du använda BigInteger.ToString(String) metoden med formatspecificeraren "R" för att generera strängrepresentationen BigInteger av värdet. Annars bevarar strängrepresentationen BigInteger endast de 50 viktigaste siffrorna i det ursprungliga värdet och data kan gå förlorade när du använder Parse metoden för att återställa BigInteger värdet.

Parametern provider är en IFormatProvider implementering vars GetFormat metod returnerar ett NumberFormatInfo objekt som tillhandahåller kulturspecifik formateringsinformation. Parse(String, IFormatProvider) När metoden anropas anropas provider parameterns GetFormat metod och skickar den ett Type objekt som representerar NumberFormatInfo typen. Metoden GetFormat returnerar sedan objektet NumberFormatInfo som innehåller information om parameterns value format. Det finns tre sätt att använda parametern provider för att ange anpassad formateringsinformation till parsningsåtgärden:

• Du kan skicka ett CultureInfo objekt som representerar kulturen som tillhandahåller formateringsinformation. Dess GetFormat metod returnerar det NumberFormatInfo objekt som innehåller numerisk formateringsinformation för den kulturen.

• Du kan skicka det faktiska NumberFormatInfo objektet som innehåller numerisk formateringsinformation. (Dess implementering av GetFormat just returnerar sig själv.)

• Du kan skicka ett anpassat objekt som implementerar IFormatProvider. Metoden GetFormat instansierar och returnerar objektet NumberFormatInfo som tillhandahåller formateringsinformation.

Om provider är nulltolkas formateringen för value baserat på objektet i NumberFormatInfo den aktuella kulturen.

Se även

• TryParse

Parse(String, NumberStyles, IFormatProvider)

Konverterar strängrepresentationen av ett tal i ett angivet format och kulturspecifikt format till dess BigInteger motsvarighet.

public:
 static System::Numerics::BigInteger Parse(System::String ^ value, System::Globalization::NumberStyles style, IFormatProvider ^ provider);

public static System.Numerics.BigInteger Parse(string value, System.Globalization.NumberStyles style, IFormatProvider provider);

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

Public Shared Function Parse (value As String, style As NumberStyles, provider As IFormatProvider) As BigInteger

Parametrar

value

String

En sträng som innehåller ett tal som ska konverteras.

style

NumberStyles

En bitvis kombination av uppräkningsvärdena som anger det tillåtna formatet för value.

provider

IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om value.

Returer

BigInteger

Ett värde som motsvarar det tal som anges i parametern value .

Undantag

ArgumentException

style är inte ett NumberStyles värde.

-eller-

style AllowHexSpecifier innehåller flaggan eller HexNumber tillsammans med ett annat värde.

ArgumentNullException

value är null.

FormatException

value uppfyller inte det indatamönster som anges av style.

Exempel

I följande exempel görs flera anrop till Parse(String, NumberStyles, IFormatProvider) metoden med hjälp av olika kombinationer av värden för parametrarna style och provider .

// Call parse with default values of style and provider
Console.WriteLine(BigInteger.Parse("  -300   ",
                  NumberStyles.Integer, CultureInfo.CurrentCulture));
// Call parse with default values of style and provider supporting tilde as negative sign
Console.WriteLine(BigInteger.Parse("   ~300  ",
                                   NumberStyles.Integer, new BigIntegerFormatProvider()));
// Call parse with only AllowLeadingWhite and AllowTrailingWhite
// Exception thrown because of presence of negative sign
try
{
   Console.WriteLine(BigInteger.Parse("    ~300   ",
                                NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite,
                                new BigIntegerFormatProvider()));
}
catch (FormatException e)
{
   Console.WriteLine("{0}: \n   {1}", e.GetType().Name, e.Message);
}
// Call parse with only AllowHexSpecifier
// Exception thrown because of presence of negative sign
try
{
   Console.WriteLine(BigInteger.Parse("-3af", NumberStyles.AllowHexSpecifier,
                                      new BigIntegerFormatProvider()));
}
catch (FormatException e)
{
   Console.WriteLine("{0}: \n   {1}", e.GetType().Name, e.Message);
}
// Call parse with only NumberStyles.None
// Exception thrown because of presence of white space and sign
try
{
   Console.WriteLine(BigInteger.Parse(" -300 ", NumberStyles.None,
                                      new BigIntegerFormatProvider()));
}
catch (FormatException e)
{
   Console.WriteLine("{0}: \n   {1}", e.GetType().Name, e.Message);
}
// The example displays the followingoutput:
//       -300
//       -300
//       FormatException:
//          The value could not be parsed.
//       FormatException:
//          The value could not be parsed.
//       FormatException:
//          The value could not be parsed.

    // Call parse with default values of style and provider
    printfn $"""{BigInteger.Parse("  -300   ", NumberStyles.Integer, CultureInfo.CurrentCulture)}"""

    // Call parse with default values of style and provider supporting tilde as negative sign
    printfn $"""{BigInteger.Parse("   ~300  ", NumberStyles.Integer, new BigIntegerFormatProvider())}"""

    // Call parse with only AllowLeadingWhite and AllowTrailingWhite
    // Exception thrown because of presence of negative sign
    try
        printfn
            $"""{BigInteger.Parse(
                     "    ~300   ",
                     NumberStyles.AllowLeadingWhite ||| NumberStyles.AllowTrailingWhite,
                     new BigIntegerFormatProvider()
                 )}"""
    with :? FormatException as e ->
        printfn $"{e.GetType().Name}: \n   {e.Message}"

    // Call parse with only AllowHexSpecifier
    // Exception thrown because of presence of negative sign
    try
        printfn $"""{BigInteger.Parse("-3af", NumberStyles.AllowHexSpecifier, new BigIntegerFormatProvider())}"""
    with :? FormatException as e ->
        printfn $"{e.GetType().Name}: \n   {e.Message}"

    // Call parse with only NumberStyles.None
    // Exception thrown because of presence of white space and sign
    try
        printfn $"""{BigInteger.Parse(" -300 ", NumberStyles.None, new BigIntegerFormatProvider())}"""
    with :? FormatException as e ->
        printfn $"{e.GetType().Name}: \n   {e.Message}"
// The example displays the followingoutput:
//       -300
//       -300
//       FormatException:
//          The value could not be parsed.
//       FormatException:
//          The value could not be parsed.
//       FormatException:
//          The value could not be parsed.

' Call parse with default values of style and provider
Console.WriteLine(BigInteger.Parse("  -300   ", _
                  NumberStyles.Integer, CultureInfo.CurrentCulture))
' Call parse with default values of style and provider supporting tilde as negative sign
Console.WriteLine(BigInteger.Parse("   ~300  ", _
                                   NumberStyles.Integer, New BigIntegerFormatProvider()))
' Call parse with only AllowLeadingWhite and AllowTrailingWhite
' Exception thrown because of presence of negative sign
Try
   Console.WriteLIne(BigInteger.Parse("    ~300   ", _
                                      NumberStyles.AllowLeadingWhite Or NumberStyles.AllowTrailingWhite, _
                                      New BigIntegerFormatProvider()))
Catch e As FormatException
   Console.WriteLine("{0}: {1}   {2}", e.GetType().Name, vbCrLf, e.Message)
End Try                                   
' Call parse with only AllowHexSpecifier
' Exception thrown because of presence of negative sign
Try
   Console.WriteLIne(BigInteger.Parse("-3af", NumberStyles.AllowHexSpecifier, _
                                      New BigIntegerFormatProvider()))
Catch e As FormatException
   Console.WriteLine("{0}: {1}   {2}", e.GetType().Name, vbCrLf, e.Message)
End Try                                 
' Call parse with only NumberStyles.None
' Exception thrown because of presence of white space and sign
Try
   Console.WriteLIne(BigInteger.Parse(" -300 ", NumberStyles.None, _
                                      New BigIntegerFormatProvider()))
Catch e As FormatException
   Console.WriteLine("{0}: {1}   {2}", e.GetType().Name, vbCrLf, e.Message)
End Try
' The example displays the following output:
'       -300
'       -300
'       FormatException:
'          The value could not be parsed.
'       FormatException:
'          The value could not be parsed.
'       FormatException:
'          The value could not be parsed.

Ett antal enskilda anrop till Parse(String, NumberStyles, IFormatProvider) metoden skickar en instans av följande BigIntegerFormatProvider klass, som definierar en tilde (~) som det negativa tecknet.

public class BigIntegerFormatProvider : IFormatProvider
{
   public object GetFormat(Type formatType)
   {
      if (formatType == typeof(NumberFormatInfo))
      {
         NumberFormatInfo numberFormat = new NumberFormatInfo();
         numberFormat.NegativeSign = "~";
         return numberFormat;
      }
      else
      {
         return null;
      }
   }
}

type BigIntegerFormatProvider() =
    interface IFormatProvider with

        member _.GetFormat(formatType: Type) =
            if formatType = typeof<NumberFormatInfo> then
                let numberFormat = NumberFormatInfo()
                numberFormat.NegativeSign <- "~"
                numberFormat
            else
                null

Public Class BigIntegerFormatProvider : Implements IFormatProvider
   Public Function GetFormat(formatType As Type) As Object _
                            Implements IFormatProvider.GetFormat
      If formatType Is GetType(NumberFormatInfo) Then
         Dim numberFormat As New NumberFormatInfo
         numberFormat.NegativeSign = "~"
         Return numberFormat
      Else
         Return Nothing
      End If      
   End Function
End Class

Kommentarer

Parametern style definierar formatelementen (till exempel blanksteg, symbolen för positiva eller negativa tecken, gruppavgränsningssymbolen eller decimaltecknet) som tillåts i parametern value för att parsningsåtgärden ska lyckas. styles måste vara en kombination av bitflaggor från NumberStyles uppräkningen. Parametern style gör den här metoden användbar när value den innehåller strängrepresentationen av ett hexadecimalt värde, när talsystemet (decimal eller hexadecimalt) som representeras av value endast är känt vid körning, eller när du vill neka tomt utrymme eller en teckensymbol i value.

Beroende på värdet för stylekan parametern value innehålla följande element:

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

Om style innehåller NumberStyles.AllowHexSpecifierkan parametern value innehålla följande element:

[ws]hexdigits[ws]

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

Element	Description
Ws	Valfritt blanksteg. Tomt utrymme kan visas i början av value om style innehåller NumberStyles.AllowLeadingWhite flaggan, och det kan visas i slutet av value 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 kultur som anges av parametern provider . Den aktuella kulturens valutasymbol kan visas i value om style den NumberStyles.AllowCurrencySymbol innehåller flaggan.
signera	Ett valfritt tecken. Tecknet kan visas i början av value om style innehåller NumberStyles.AllowLeadingSign flaggan, och det kan visas i slutet av value om style innehåller NumberStyles.AllowTrailingSign flaggan. Parenteser kan användas i value 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 gruppavgränsare. Gruppavgränsarsymbolen för kulturen som anges av provider kan visas i value om style den NumberStyles.AllowThousands innehåller flaggan.
.	Ett kulturspecifikt decimaltecken. Decimaltecknet för den kultur som anges av provider kan visas i value 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 FormatException .
E	Tecknet "e" eller "E", som anger att värdet representeras i exponentiell (vetenskaplig) notation. Parametern value 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.

Note

Alla avslutande NUL-tecken (U+0000) i s ignoreras av parsningsåtgärden, oavsett argumentets style värde.

En sträng med endast siffror (vilket motsvarar NumberStyles.None formatet) parsar alltid korrekt. De flesta av de återstående NumberStyles medlemmarna styr element som kan finnas, 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 value.

NumberStyles-värde	Element som tillåts i värde utöver siffror
None	Endast elementet digits .
AllowDecimalPoint	Decimaltecknet (.) och bråksiffriga element.
AllowExponent	Tecknet "e" eller "E", som indikerar exponentiell notation. tillsammans med exponential_digits.
AllowLeadingWhite	WS-elementet i början av value.
AllowTrailingWhite	WS-elementet i slutet av value.
AllowLeadingSign	Teckenelementet i början av value.
AllowTrailingSign	Teckenelementet i slutet av value.
AllowParentheses	Teckenelementet i form av parenteser som omger det numeriska värdet.
AllowThousands	Gruppavgränsaren (,).
AllowCurrencySymbol	Valutaelementet ($).
Currency	Alla element. Kan dock value inte representera ett hexadecimalt tal eller ett tal i exponentiell notation.
Float	WS-elementet i början eller slutet av value, signerar i början av valueoch decimaltecknet (.). Parametern value kan också använda exponentiell notation.
Number	Elementen ws, sign, gruppavgränsare (,) och decimaltecken (.).
Any	Alla element. Kan dock value inte representera ett hexadecimalt tal.

Important

Om du använder Parse metoden för att avrunda strängrepresentationen av ett BigInteger värde som utdata från ToString metoden, bör du använda BigInteger.ToString(String) metoden med formatspecificeraren "R" för att generera strängrepresentationen BigInteger av värdet. Annars bevarar strängrepresentationen BigInteger endast de 50 viktigaste siffrorna i det ursprungliga värdet och data kan gå förlorade när du använder Parse metoden för att återställa BigInteger värdet.

Till skillnad från de andra NumberStyles värdena, som tillåter men inte kräver förekomst av vissa formatelement i value, NumberStyles.AllowHexSpecifier innebär formatvärdet att de enskilda numeriska tecknen i value alltid tolkas som hexadecimala tecken. Giltiga hexadecimala tecken är 0-9, A-F och a-f. De enda andra flaggorna som kan kombineras med parametern style är NumberStyles.AllowLeadingWhite och NumberStyles.AllowTrailingWhite. (Uppräkningen NumberStyles innehåller ett sammansatt talformat, HexNumber, som innehåller båda blankstegsflaggor.)

Note

Om value är strängrepresentationen av ett hexadecimalt tal kan det inte föregås av någon dekoration (till exempel 0x eller &h) som särskiljer det som ett hexadecimalt tal. Detta gör att konverteringen misslyckas.

Om value är en hexadecimal sträng Parse(String, NumberStyles) tolkas value metoden som ett negativt tal som lagras med hjälp av två komplementrepresentation om de två första hexadecimala siffrorna är större än eller lika med 0x80. Med andra ord tolkar metoden den högsta biten av den första byteen i value som teckenbiten. För att säkerställa att en hexadecimal sträng tolkas korrekt som ett positivt tal måste den första siffran i value ha värdet noll. Metoden tolkas 0x80 till exempel som ett negativt värde, men den tolkar antingen 0x080 eller 0x0080 som ett positivt värde. I följande exempel visas skillnaden mellan hexadecimala strängar som representerar negativa och positiva värden.

using System;
using System.Globalization;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      string[] hexStrings = { "80", "E293", "F9A2FF", "FFFFFFFF",
                              "080", "0E293", "0F9A2FF", "0FFFFFFFF",
                              "0080", "00E293", "00F9A2FF", "00FFFFFFFF" };
      foreach (string hexString in hexStrings)
      {
         BigInteger number = BigInteger.Parse(hexString, NumberStyles.AllowHexSpecifier);
         Console.WriteLine("Converted 0x{0} to {1}.", hexString, number);
      }
   }
}
// The example displays the following output:
//       Converted 0x80 to -128.
//       Converted 0xE293 to -7533.
//       Converted 0xF9A2FF to -417025.
//       Converted 0xFFFFFFFF to -1.
//       Converted 0x080 to 128.
//       Converted 0x0E293 to 58003.
//       Converted 0x0F9A2FF to 16360191.
//       Converted 0x0FFFFFFFF to 4294967295.
//       Converted 0x0080 to 128.
//       Converted 0x00E293 to 58003.
//       Converted 0x00F9A2FF to 16360191.
//       Converted 0x00FFFFFFFF to 4294967295.

open System.Globalization
open System.Numerics

let hexStrings =
    [| "80"
       "E293"
       "F9A2FF"
       "FFFFFFFF"
       "080"
       "0E293"
       "0F9A2FF"
       "0FFFFFFFF"
       "0080"
       "00E293"
       "00F9A2FF"
       "00FFFFFFFF" |]

for hexString in hexStrings do
    let number = BigInteger.Parse(hexString, NumberStyles.AllowHexSpecifier)
    printfn $"Converted 0x{hexString} to {number:N0}."
// The example displays the following output:
//       Converted 0x80 to -128.
//       Converted 0xE293 to -7533.
//       Converted 0xF9A2FF to -417025.
//       Converted 0xFFFFFFFF to -1.
//       Converted 0x080 to 128.
//       Converted 0x0E293 to 58003.
//       Converted 0x0F9A2FF to 16360191.
//       Converted 0x0FFFFFFFF to 4294967295.
//       Converted 0x0080 to 128.
//       Converted 0x00E293 to 58003.
//       Converted 0x00F9A2FF to 16360191.
//       Converted 0x00FFFFFFFF to 4294967295.

Imports System.Globalization
Imports System.Numerics

Module Example
   Public Sub Main()
      Dim hexStrings() As String = { "80", "E293", "F9A2FF", "FFFFFFFF", 
                                     "080", "0E293", "0F9A2FF", "0FFFFFFFF",  
                                     "0080", "00E293", "00F9A2FF", "00FFFFFFFF" }
      For Each hexString As String In hexStrings
         Dim number As BigInteger = BigInteger.Parse(hexString, NumberStyles.AllowHexSpecifier)
         Console.WriteLine("Converted 0x{0} to {1}.", hexString, number)
      Next         
   End Sub
End Module
' The example displays the following output:
'       Converted 0x80 to -128.
'       Converted 0xE293 to -7533.
'       Converted 0xF9A2FF to -417025.
'       Converted 0xFFFFFFFF to -1.
'       Converted 0x080 to 128.
'       Converted 0x0E293 to 58003.
'       Converted 0x0F9A2FF to 16360191.
'       Converted 0x0FFFFFFFF to 4294967295.
'       Converted 0x0080 to 128.
'       Converted 0x00E293 to 58003.
'       Converted 0x00F9A2FF to 16360191.
'       Converted 0x00FFFFFFFF to 4294967295.

Parametern provider är en IFormatProvider implementering. Dess GetFormat metod returnerar ett NumberFormatInfo objekt som ger kulturspecifik information om formatet valueför . provider Kan vanligtvis vara något av följande:

• Ett CultureInfo objekt som representerar kulturen som innehåller numerisk formateringsinformation. Dess GetFormat metod returnerar det NumberFormatInfo objekt som innehåller numerisk formateringsinformation.

• Ett NumberFormatInfo objekt som innehåller formateringsinformation. (Dess implementering av GetFormat just returnerar sig själv.)

• Ett anpassat objekt som implementerar IFormatProvider och använder GetFormat metoden för att instansiera och returnera det NumberFormatInfo objekt som tillhandahåller formateringsinformation.

Om provider är nullNumberFormatInfo används objektet för den aktuella kulturen.

Se även

• TryParse