BigInteger.TryParse Metod

Definition

Namnområde:

System.Numerics

Sammansättning:

System.Numerics.dll

Försöker konvertera strängrepresentationen av ett tal till dess BigInteger motsvarighet och returnerar ett värde som anger om konverteringen lyckades.

Överlagringar

Name	Description
TryParse(String, BigInteger)	Försöker konvertera strängrepresentationen av ett tal till dess BigInteger motsvarighet och returnerar ett värde som anger om konverteringen lyckades.
TryParse(String, NumberStyles, IFormatProvider, BigInteger)	Försöker konvertera strängrepresentationen av ett tal i ett angivet format och kulturspecifikt format till dess BigInteger motsvarighet och returnerar ett värde som anger om konverteringen lyckades.

TryParse(String, BigInteger)

Försöker konvertera strängrepresentationen av ett tal till dess BigInteger motsvarighet och returnerar ett värde som anger om konverteringen lyckades.

public:
 static bool TryParse(System::String ^ value, [Runtime::InteropServices::Out] System::Numerics::BigInteger % result);

public static bool TryParse(string value, out System.Numerics.BigInteger result);

static member TryParse : string * BigInteger -> bool

Public Shared Function TryParse (value As String, ByRef result As BigInteger) As Boolean

Parametrar

value

String

Strängrepresentationen av ett tal.

result

BigInteger

När den här metoden returneras innehåller motsvarande BigInteger det tal som finns i value, eller noll (0) om konverteringen misslyckas. Konverteringen misslyckas om parametern value är null eller inte har rätt format. Den här parametern skickas oinitierad.

Returer

Boolean

true om value har konverterats, annars false.

Undantag

ArgumentNullException

value är null.

Exempel

I följande exempel används TryParse(String, BigInteger) metoden för att instansiera två BigInteger objekt. Om konverteringarna lyckas multipliceras varje objekt med ett annat tal och anropar Compare sedan metoden för att fastställa relationen mellan de två objekten.

BigInteger number1, number2;
bool succeeded1 = BigInteger.TryParse("-12347534159895123", out number1);
bool succeeded2 = BigInteger.TryParse("987654321357159852", out number2);
if (succeeded1 && succeeded2)
{
   number1 *= 3;
   number2 *= 2;
   switch (BigInteger.Compare(number1, number2))
   {
      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;
   }
}
else
{
   if (!succeeded1)
      Console.WriteLine("Unable to initialize the first BigInteger value.");

   if (!succeeded2)
      Console.WriteLine("Unable to initialize the second BigInteger value.");
}
// The example displays the following output:
//      1975308642714319704 is greater than -37042602479685369.

    let mutable number1 = BigInteger.Zero
    let mutable number2 = BigInteger.Zero

    let succeeded1 = BigInteger.TryParse("-12347534159895123", &number1)
    let succeeded2 = BigInteger.TryParse("987654321357159852", &number2)

    if succeeded1 && succeeded2 then
        number1 <- number1 * 3I
        number2 <- number2 * 2I

        match BigInteger.Compare(number1, number2) with
        | -1 -> printfn $"{number2} is greater than {number2}."
        | 0 -> printfn $"{number1} is equal to {number2}."
        | 1
        | _ -> printfn $"{number1} is greater than {number2}."
    else
        if not succeeded1 then
            printfn "Unable to initialize the first BigInteger value."

        if not succeeded2 then
            printfn "Unable to initialize the second BigInteger value."

// The example displays the following output:
//      1975308642714319704 is greater than -37042602479685369.

Dim number1 As BigInteger = BigInteger.Zero
Dim number2 As BigInteger = BigInteger.Zero
Dim succeeded1 As Boolean = BigInteger.TryParse("-12347534159895123", number1)
Dim succeeded2 As Boolean = BigInteger.TryParse("987654321357159852", number2)
If succeeded1 AndAlso succeeded2
   number1 *= 3
   number2 *= 2
   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      
Else
   If Not succeeded1 Then 
      Console.WriteLine("Unable to initialize the first BigInteger value.")
   End If
   If Not succeeded2 Then
      Console.WriteLine("Unable to initialize the second BigInteger value.")
   
   End If
End If
' The example displays the following output:
'      1975308642714319704 is greater than -37042602479685369.

Kommentarer

Metoden TryParse(String, BigInteger) liknar Parse(String) metoden, förutom att den inte utlöser ett undantag om konverteringen misslyckas. Den här metoden eliminerar behovet av att använda undantagshantering för att testa för en FormatException om value är ogiltig och kan inte parsas.

Parametern value ska vara strängrepresentationen av ett decimaltal 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 decimalsiffror från 0 till 9.

Note

Strängen som anges av parametern value får inte innehålla några gruppavgränsare eller decimaltecken, och den får inte ha en decimaldel.

Parametern value tolkas med hjälp NumberStyles.Integer av formatet . Förutom decimaltalen tillåts endast inledande och avslutande blanksteg med ett inledande tecken. Om du uttryckligen vill definiera formatelementen med den kulturspecifika formateringsinformation som kan finnas i valueanropar TryParse(String, NumberStyles, IFormatProvider, BigInteger) du metoden.

Parametern value parsas med hjälp av formateringsinformationen i ett NumberFormatInfo objekt för den aktuella kulturen. Mer information finns i NumberFormatInfo.CurrentInfo.

Den här överlagringen tolkar alla siffror i parametern value som decimalsiffror. Om du vill parsa strängrepresentationen av ett hexadecimalt nummer anropar du överlagringen TryParse(String, NumberStyles, IFormatProvider, BigInteger) i stället.

Se även

• ToString(String)
• Parse

TryParse(String, NumberStyles, IFormatProvider, BigInteger)

Försöker konvertera strängrepresentationen av ett tal i ett angivet format och kulturspecifikt format till dess BigInteger motsvarighet och returnerar ett värde som anger om konverteringen lyckades.

public:
 static bool TryParse(System::String ^ value, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::Numerics::BigInteger % result);

public static bool TryParse(string value, System.Globalization.NumberStyles style, IFormatProvider provider, out System.Numerics.BigInteger result);

static member TryParse : string * System.Globalization.NumberStyles * IFormatProvider * BigInteger -> bool

Public Shared Function TryParse (value As String, style As NumberStyles, provider As IFormatProvider, ByRef result As BigInteger) As Boolean

Parametrar

value

String

Strängrepresentationen av ett tal. Strängen tolkas med det format som anges av style.

style

NumberStyles

En bitvis kombination av uppräkningsvärden som anger de formatelement som kan finnas i value. Ett typiskt värde att ange är Integer.

provider

IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om value.

result

BigInteger

När den här metoden returneras innehåller motsvarande BigInteger det tal som finns i value, eller Zero om konverteringen misslyckades. Konverteringen misslyckas om parametern value är null eller inte är i ett format som är kompatibelt med style. Den här parametern skickas oinitierad.

Returer

Boolean

trueom parametern value har konverterats, annars . false

Undantag

ArgumentException

style är inte ett NumberStyles värde.

-eller-

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

Exempel

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

string numericString;
BigInteger number = BigInteger.Zero;

// Call TryParse with default values of style and provider.
numericString = "  -300   ";
if (BigInteger.TryParse(numericString, NumberStyles.Integer,
                       null, out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with the default value of style and
// a provider supporting the tilde as negative sign.
numericString = "  -300   ";
if (BigInteger.TryParse(numericString, NumberStyles.Integer,
                       new BigIntegerFormatProvider(), out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with only AllowLeadingWhite and AllowTrailingWhite.
// Method returns false because of presence of negative sign.
numericString = "  -500   ";
if (BigInteger.TryParse(numericString,
                        NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite,
                        new BigIntegerFormatProvider(), out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with AllowHexSpecifier and a hex value.
numericString = "F14237FFAAC086455192";
if (BigInteger.TryParse(numericString,
                        NumberStyles.AllowHexSpecifier,
                        null, out number))
   Console.WriteLine("'{0}' was converted to {1} (0x{1:x}).",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with AllowHexSpecifier and a negative hex value.
// Conversion fails because of presence of negative sign.
numericString = "-3af";
if (BigInteger.TryParse(numericString, NumberStyles.AllowHexSpecifier,
                       new BigIntegerFormatProvider(), out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with only NumberStyles.None.
// Conversion fails because of presence of white space and sign.
numericString = " -300 ";
if (BigInteger.TryParse(numericString, NumberStyles.None,
                       new BigIntegerFormatProvider(), out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with NumberStyles.Any and a provider for the fr-FR culture.
// Conversion fails because the string is formatted for the en-US culture.
numericString = "9,031,425,666,123,546.00";
if (BigInteger.TryParse(numericString, NumberStyles.Any,
                       new CultureInfo("fr-FR"), out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with NumberStyles.Any and a provider for the fr-FR culture.
// Conversion succeeds because the string is properly formatted
// For the fr-FR culture.
numericString = "9 031 425 666 123 546,00";
if (BigInteger.TryParse(numericString, NumberStyles.Any,
                       new CultureInfo("fr-FR"), out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);
// The example displays the following output:
//    '  -300   ' was converted to -300.
//    Conversion of '  -300   ' to a BigInteger failed.
//    Conversion of '  -500   ' to a BigInteger failed.
//    'F14237FFAAC086455192' was converted to -69613977002644837412462 (0xf14237ffaac086455192).
//    Conversion of '-3af' to a BigInteger failed.
//    Conversion of ' -300 ' to a BigInteger failed.
//    Conversion of '9,031,425,666,123,546.00' to a BigInteger failed.
//    '9 031 425 666 123 546,00' was converted to 9031425666123546.

    // Call TryParse with default values of style and provider.
    let numericString = "  -300   "

    match BigInteger.TryParse(numericString, NumberStyles.Integer, null) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}"
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with the default value of style and
    // a provider supporting the tilde as negative sign.
    let numericString = "  -300   "

    match BigInteger.TryParse(numericString, NumberStyles.Integer, new BigIntegerFormatProvider()) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}"
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with only AllowLeadingWhite and AllowTrailingWhite.
    // Method returns false because of presence of negative sign.
    let numericString = "  -500   "

    match
        BigInteger.TryParse(
            numericString,
            NumberStyles.AllowLeadingWhite ||| NumberStyles.AllowTrailingWhite,
            new BigIntegerFormatProvider()
        )
    with
    | true, number -> printfn $"The string '{numericString}' parses to {number}"
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with AllowHexSpecifier and a hex value.
    let numericString = "F14237FFAAC086455192"

    match BigInteger.TryParse(numericString, NumberStyles.AllowHexSpecifier, null) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}, or 0x{number:x}."
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with AllowHexSpecifier and a negative hex value.
    // Conversion fails because of presence of negative sign.
    let numericString = "-3af"

    match BigInteger.TryParse(numericString, NumberStyles.AllowHexSpecifier, null) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}, or 0x{number:x}."
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with only NumberStyles.None.
    // Conversion fails because of presence of white space and sign.
    let numericString = " -300 "

    match BigInteger.TryParse(numericString, NumberStyles.None, new BigIntegerFormatProvider()) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}"
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with NumberStyles.Any and a provider for the fr-FR culture.
    // Conversion fails because the string is formatted for the en-US culture.
    let numericString = "9,031,425,666,123,546.00"

    match BigInteger.TryParse(numericString, NumberStyles.Any, new CultureInfo("fr-FR")) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}"
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with NumberStyles.Any and a provider for the fr-FR culture.
    // Conversion succeeds because the string is properly formatted
    // For the fr-FR culture.
    let numericString = "9 031 425 666 123 546,00"

    match BigInteger.TryParse(numericString, NumberStyles.Any, new CultureInfo("fr-FR")) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}"
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

// The example displays the following output:
//    '  -300   ' was converted to -300.
//    Conversion of '  -300   ' to a BigInteger failed.
//    Conversion of '  -500   ' to a BigInteger failed.
//    'F14237FFAAC086455192' was converted to -69613977002644837412462 (0xf14237ffaac086455192).
//    Conversion of '-3af' to a BigInteger failed.
//    Conversion of ' -300 ' to a BigInteger failed.
//    Conversion of '9,031,425,666,123,546.00' to a BigInteger failed.
//    '9 031 425 666 123 546,00' was converted to 9031425666123546.

Dim numericString As String
Dim number As BigInteger = BigInteger.Zero

' Call TryParse with default values of style and provider.
numericString = "  -300   "
If BigInteger.TryParse(numericString, NumberStyles.Integer,
                       Nothing, number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If                                             

' Call TryParse with the default value of style and 
' a provider supporting the tilde as negative sign.
numericString = "  -300   "
If BigInteger.TryParse(numericString, NumberStyles.Integer,
                       New BigIntegerFormatProvider(), number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If                                             

' Call TryParse with only AllowLeadingWhite and AllowTrailingWhite.
' Method returns false because of presence of negative sign.
numericString = "  -500   "
If BigInteger.TryParse(numericString,
                    NumberStyles.AllowLeadingWhite Or NumberStyles.AllowTrailingWhite,
                    New BigIntegerFormatProvider(), number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If                                             

' Call TryParse with AllowHexSpecifier and a hex value.
numericString = "F14237FFAAC086455192"
If BigInteger.TryParse(numericString,
                    NumberStyles.AllowHexSpecifier,
                    Nothing, number) Then
   Console.WriteLine("'{0}' was converted to {1} (0x{1:x}).",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If                                             

' Call TryParse with AllowHexSpecifier and a negative hex value.
' Conversion fails because of presence of negative sign.
numericString = "-3af"
If BigInteger.TryParse(numericString, NumberStyles.AllowHexSpecifier,
                       New BigIntegerFormatProvider(), number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If                                             

' Call TryParse with only NumberStyles.None.
' Conversion fails because of presence of white space and sign.
numericString = " -300 "
If BigInteger.TryParse(numericString, NumberStyles.None,
                       New BigIntegerFormatProvider(), number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If 
                                            
' Call TryParse with NumberStyles.Any and a provider for the fr-FR culture.
' Conversion fails because the string is formatted for the en-US culture.
numericString = "9,031,425,666,123,546.00"
If BigInteger.TryParse(numericString, NumberStyles.Any,
                       New CultureInfo("fr-FR"), number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If

' Call TryParse with NumberStyles.Any and a provider for the fr-FR culture.
' Conversion succeeds because the string is properly formatted 
' For the fr-FR culture.
numericString = "9 031 425 666 123 546,00"
If BigInteger.TryParse(numericString, NumberStyles.Any,
                       New CultureInfo("fr-FR"), number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If
' The example displays the following output:
'    '  -300   ' was converted to -300.
'    Conversion of '  -300   ' to a BigInteger failed.
'    Conversion of '  -500   ' to a BigInteger failed.
'    'F14237FFAAC086455192' was converted to -69613977002644837412462 (0xf14237ffaac086455192).
'    Conversion of '-3af' to a BigInteger failed.
'    Conversion of ' -300 ' to a BigInteger failed.
'    Conversion of '9,031,425,666,123,546.00' to a BigInteger failed.
'    '9 031 425 666 123 546,00' was converted to 9031425666123546.

Ett antal enskilda anrop till TryParse(String, NumberStyles, IFormatProvider, BigInteger) 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 = new 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

Metoden TryParse(String, NumberStyles, IFormatProvider, BigInteger) liknar Parse(String, NumberStyles, IFormatProvider) metoden, förutom att den inte utlöser ett undantag om konverteringen misslyckas. Den här metoden eliminerar behovet av att använda undantagshantering för att testa för en FormatException om value är ogiltig och kan inte parsas korrekt.

Parametern style definierar formatelementen (till exempel tomt utrymme eller ett positivt eller negativt tecken) som tillåts i parametern value 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 value innehålla följande element:

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

Om parametern style innehåller 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, eller i slutet av value om style innehåller NumberStyles.AllowTrailingWhite flaggan.
$	En kulturspecifik valutasymbol. Dess position i strängen definieras av CurrencyPositivePattern egenskapen för objektet NumberFormatInfo som returneras av GetFormat parametermetoden provider . Valutasymbolen 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	En sekvens med siffror från 0 till 9.
,	En kulturspecifik gruppavgränsare. Gruppavgränsaren 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 kulturen som anges av provider kan visas i value om style den NumberStyles.AllowDecimalPoint innehåller flaggan.
fractional_digits	En eller flera förekomster av siffran 0. Bråksiffror kan bara visas i value om style den NumberStyles.AllowDecimalPoint innehåller flaggan.
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.
exponential_digits	En sekvens med siffror från 0 till 9. 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 decimalsiffror (vilket motsvarar NumberStyles.None flaggan) parsar alltid korrekt. De flesta av de återstående NumberStyles medlemmarna styr element som kan finnas, 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 value.

Icke-sammansatta NumberStyles värden	Element som tillåts i värde utöver siffror
None	Endast decimalsiffror.
AllowDecimalPoint	Decimaltecknet (.) och fractional_digits element. Men fractional_digits får bara bestå av en eller flera 0 siffror, eller så returnerar falsemetoden .
AllowExponent	Tecknet "e" eller "E", som anger exponentiell notation, tillsammans med exponential_digits. Om value representerar ett tal i exponentiell notation får det inte ha en icke-noll, bråkkomponent.
AllowLeadingWhite	WS-elementet i början av value.
AllowTrailingWhite	WS-elementet i slutet av value.
AllowLeadingSign	Teckenelementet före siffror.
AllowTrailingSign	Teckenelementet efter siffror.
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, group separator (,) och decimaltecknet (.).
Any	Alla element. Kan dock value inte representera ett hexadecimalt tal.

Important

Om du använder TryParse 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 TryParse metoden för att återställa BigInteger värdet.

NumberStyles.AllowHexSpecifier Om flaggan används value måste vara ett hexadecimalt värde. De enda andra flaggorna som kan finnas i style är NumberStyles.AllowLeadingWhite och NumberStyles.AllowTrailingWhite. (Uppräkningen NumberStyles har ett sammansatt format, HexNumber, som innehåller båda blankstegsflaggorna.)

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 TryParse(String, NumberStyles, IFormatProvider, BigInteger) 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" };
      BigInteger number = BigInteger.Zero;

      foreach (string hexString in hexStrings)
      {
         if (BigInteger.TryParse(hexString, NumberStyles.AllowHexSpecifier,
                                 null, out number))
            Console.WriteLine("Converted 0x{0} to {1}.", hexString, number);
         else
            Console.WriteLine("Cannot convert '{0}' to a BigInteger.", hexString);
      }
   }
}
// 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
    match BigInteger.TryParse(hexString, NumberStyles.AllowHexSpecifier, null) with
    | true, number -> printfn $"Converted 0x{hexString} to {number}."
    | _ -> printfn $"Cannot convert '{hexString}' to a BigInteger."

// 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" }
      Dim number As BigInteger = BigInteger.Zero
      
      For Each hexString As String In hexStrings
         If BigInteger.TryParse(hexString, NumberStyles.AllowHexSpecifier, 
                                Nothing, number) Then
            Console.WriteLine("Converted 0x{0} to {1}.", hexString, number)
         Else
            Console.WriteLine("Cannot convert '{0}' to a BigInteger.", hexString)
         End If
      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 . Parametern provider kan vara något av följande:

• 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.

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

• Ett anpassat objekt som implementerar IFormatProvider. Metoden GetFormat instansierar och returnerar objektet NumberFormatInfo som tillhandahåller formateringsinformation.

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

Se även

• ToString
• Parse