BigInteger.Parse Methode

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

Parameters

Retouren

Een waarde die gelijk is aan het getal dat is opgegeven in de value parameter.

Uitzonderingen

Voorbeelden

In het volgende voorbeeld wordt de Parse(String) methode gebruikt om twee BigInteger objecten te instantiëren. Het vermenigvuldigt elk object met een ander getal en roept vervolgens de methode aan om de Compare relatie tussen de twee waarden te bepalen.

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.

Opmerkingen

De value parameter moet de tekenreeksweergave van een getal zijn in de volgende vorm.

[ws][teken]digits[ws]

Elementen in vierkante haken ([ en ]) zijn optioneel. In de volgende tabel wordt elk element beschreven.

Element	Beschrijving
Ws	Optionele witruimte.
ondertekenen	Een optioneel teken. Geldige tekens worden bepaald door de NumberFormatInfo.NegativeSign en NumberFormatInfo.PositiveSign eigenschappen van de huidige cultuur.
Cijfers	Een reeks cijfers tussen 0 en 9. Voorloopnullen worden genegeerd.

De value parameter wordt geparseerd met behulp van de opmaakgegevens in een System.Globalization.NumberFormatInfo object dat is geïnitialiseerd voor de huidige systeemcultuur. Zie NumberFormatInfo.CurrentInfo voor meer informatie. Als u een tekenreeks wilt parseren met behulp van de opmaakgegevens van een specifieke cultuur, gebruikt u de Parse(String, IFormatProvider) methode.

Zie ook

• TryParse

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

Parameters

Retouren

Een waarde die gelijk is aan het getal dat is opgegeven in de value parameter.

Uitzonderingen

Voorbeelden

In het volgende voorbeeld ziet u aanroepen naar de Parse(String, NumberStyles) methode met verschillende mogelijke waarden voor de style parameter. Het laat zien hoe u een tekenreeks interpreteert als een hexadecimale waarde en hoe u spaties en tekensymbolen niet toekent.

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.

Opmerkingen

De style parameter definieert de stijlelementen (zoals witruimte, het positieve of negatieve tekensymbool, het teken voor het groepsscheidingsteken of het decimale puntsymbool) die zijn toegestaan in de value parameter om de parseringsbewerking te laten slagen. styles moet een combinatie zijn van bitvlagmen uit de NumberStyles opsomming. De style parameter maakt deze methode overbelast wanneer value de tekenreeksweergave van een hexadecimale waarde bevat, wanneer het getalsysteem (decimaal of hexadecimaal) dat wordt vertegenwoordigd value door alleen tijdens runtime bekend is, of wanneer u witruimte of een tekensymbool valuewilt weigeren.

Afhankelijk van de waarde van style, kan de value parameter de volgende elementen bevatten:

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

Indien style opgenomen NumberStyles.AllowHexSpecifier, kan de value parameter de volgende elementen bevatten:

[ws]hexdigits[ws]

Elementen in vierkante haken ([ en ]) zijn optioneel. In de volgende tabel wordt elk element beschreven.

Element	Beschrijving
Ws	Optionele witruimte. Witruimte kan aan het begin van value de NumberStyles.AllowLeadingWhitestyle vlag worden weergegeven en kan aan het einde van value de vlag worden weergegeven.styleNumberStyles.AllowTrailingWhite
$	Een cultuurspecifiek valutasymbool. De positie in de tekenreeks wordt gedefinieerd door de NumberFormatInfo.CurrencyNegativePattern en NumberFormatInfo.CurrencyPositivePattern eigenschappen van de huidige cultuur. Het valutasymbool van de huidige cultuur kan worden weergegeven als valuestyle deze de NumberStyles.AllowCurrencySymbol vlag bevat.
ondertekenen	Een optioneel teken. Het teken kan aan het begin van value de vlag worden weergegeven als style deze de NumberStyles.AllowLeadingSign vlag bevat en kan worden weergegeven aan het einde van value de vlag.styleNumberStyles.AllowTrailingSign Haakjes kunnen worden gebruikt value om een negatieve waarde aan te geven als style deze de NumberStyles.AllowParentheses vlag bevat.
Cijfers fractional_digits exponential_digits	Een reeks cijfers van 0 tot en met 9. Voor fractional_digits is alleen het cijfer 0 geldig.
,	Een cultuurspecifiek groepsscheidingsteken. Het groepsscheidingsteken van de huidige cultuur kan worden weergegeven als valuestyle deze de NumberStyles.AllowThousands vlag bevat.
.	Een cultuurspecifiek decimaalteken. Het decimale puntsymbool van de huidige cultuur kan worden weergegeven value als style deze de NumberStyles.AllowDecimalPoint vlag bevat. Alleen het cijfer 0 kan worden weergegeven als een breukcijfer om de parseringsbewerking te laten slagen; als fractional_digits een ander cijfer bevat, wordt er een FormatException gegenereerd.
E	Het teken "e" of "E", dat aangeeft dat de waarde wordt weergegeven in exponentiële (wetenschappelijke) notatie. De value parameter kan een getal in exponentiële notatie vertegenwoordigen als style deze de NumberStyles.AllowExponent vlag bevat.
hexdigits	Een reeks hexadecimale cijfers van 0 tot en met f of 0 tot en met F.

Een tekenreeks met alleen cijfers (die overeenkomt met de NumberStyles.None stijl) parseert altijd succesvol. De meeste resterende NumberStyles leden bepalen elementen die mogelijk aanwezig zijn, maar die niet aanwezig zijn, in de invoertekenreeks. De volgende tabel geeft aan hoe afzonderlijke NumberStyles leden van invloed zijn op de elementen die aanwezig kunnen zijn in value.

NumberStyles waarde	Elementen die naast cijfers zijn toegestaan value
None	Alleen het cijferelement .
AllowDecimalPoint	De decimale puntelementen (.) en fractionele cijfers .
AllowExponent	Het teken "e" of "E", dat exponentiële notatie aangeeft, samen met exponential_digits.
AllowLeadingWhite	Het ws-element aan het begin van value.
AllowTrailingWhite	Het ws-element aan het einde van value.
AllowLeadingSign	Het tekenelement aan het begin van value.
AllowTrailingSign	Het tekenelement aan het einde van value.
AllowParentheses	Het tekenelement in de vorm van haakjes tussen de numerieke waarde.
AllowThousands	Het groepsscheidingsteken (,) element.
AllowCurrencySymbol	Het valutaelement ($).
Currency	Alle elementen. value Kan echter geen hexadecimaal getal of een getal in exponentiële notatie vertegenwoordigen.
Float	Het ws-element aan het begin of einde van value, teken aan het begin van valueen het decimaalteken (.). De value parameter kan ook exponentiële notatie gebruiken.
Number	De wselementen , signgroepsscheidingsteken (,) en decimaalteken (.).
Any	Alle elementen. value Kan echter geen hexadecimaal getal vertegenwoordigen.

In tegenstelling tot de andere NumberStyles waarden, die toestaan, maar niet vereisen, betekent de aanwezigheid van bepaalde stijlelementen in value, de NumberStyles.AllowHexSpecifier stijlwaarde dat de afzonderlijke numerieke tekens value altijd worden geïnterpreteerd als hexadecimale tekens. Geldige hexadecimale tekens zijn 0-9, A-F en a-f. De enige andere vlaggen die kunnen worden gecombineerd met de style parameter zijn NumberStyles.AllowLeadingWhite en NumberStyles.AllowTrailingWhite. (De NumberStyles opsomming bevat een samengestelde getalstijl, HexNumberdie beide spatievlagmen bevat.)

Als value een hexadecimale tekenreeks is, interpreteert value de Parse(String, NumberStyles) methode als een negatief getal dat is opgeslagen met behulp van de complementweergave van twee als de eerste twee hexadecimale cijfers groter zijn dan of gelijk zijn aan 0x80. Met andere woorden, de methode interpreteert de hoogste volgorde bit van de eerste byte in value als de teken-bit. Om ervoor te zorgen dat een hexadecimale tekenreeks correct wordt geïnterpreteerd als een positief getal, moet het eerste cijfer een value waarde van nul hebben. De methode interpreteert 0x80 bijvoorbeeld als een negatieve waarde, maar interpreteert een 0x080 of 0x0080 een positieve waarde. In het volgende voorbeeld ziet u het verschil tussen hexadecimale tekenreeksen die negatieve en positieve waarden vertegenwoordigen.

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.

De value parameter wordt geparseerd met behulp van de opmaakgegevens in een NumberFormatInfo object dat is geïnitialiseerd voor de huidige systeemcultuur. Als u de cultuur wilt opgeven waarvan de opmaakgegevens worden gebruikt voor de parseringsbewerking, roept u de Parse(String, NumberStyles, IFormatProvider) overbelasting aan.

Zie ook

• TryParse

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

Parameters

Retouren

Een waarde die gelijk is aan het getal dat is opgegeven in de value parameter.

Uitzonderingen

Voorbeelden

In de volgende voorbeelden ziet u twee manieren om de tilde (~) te definiëren als een negatief teken voor het opmaken van BigInteger waarden. Als u de BigInteger waarden in dezelfde indeling als de oorspronkelijke tekenreeksen wilt weergeven, moet de code de BigInteger.ToString(IFormatProvider) methode aanroepen en doorgeven aan het NumberFormatInfo object dat opmaakinformatie biedt.

In het eerste voorbeeld wordt een klasse gedefinieerd die de methode implementeert IFormatProvider en gebruikt om het NumberFormatInfo object te retourneren dat opmaakinformatie GetFormat biedt.

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

Een BigInteger object kan vervolgens worden geïnstantieerd met de volgende code:

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)

Het tweede voorbeeld is eenvoudiger. Hiermee wordt het NumberFormatInfo object doorgegeven dat opmaakgegevens aan de provider parameter levert.

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)

Opmerkingen

De value parameter moet de tekenreeksweergave van een getal zijn in de volgende vorm:

[ws][teken]digits[ws]

Elementen in vierkante haken ([ en ]) zijn optioneel. In de volgende tabel wordt elk element beschreven.

Element	Beschrijving
Ws	Optionele witruimte.
ondertekenen	Een optioneel teken. Geldige tekens worden bepaald door de NumberFormatInfo.NegativeSign en NumberFormatInfo.PositiveSign eigenschappen van het NumberFormatInfo object dat wordt geretourneerd door de methode van GetFormat het provider object.
Cijfers	Een reeks cijfers tussen 0 en 9. Voorloopnullen worden genegeerd.

De provider parameter is een IFormatProvider implementatie waarvan de GetFormat methode een NumberFormatInfo object retourneert dat cultuurspecifieke opmaakinformatie biedt. Wanneer de Parse(String, IFormatProvider) methode wordt aangeroepen, wordt de methode van GetFormat de provider parameter aangeroepen en doorgegeven aan een Type object dat het NumberFormatInfo type vertegenwoordigt. De GetFormat methode retourneert vervolgens het NumberFormatInfo object dat informatie biedt over de indeling van de value parameter. Er zijn drie manieren om de provider parameter te gebruiken om aangepaste opmaakgegevens op te geven voor de parseringsbewerking:

• U kunt een CultureInfo object doorgeven dat de cultuur vertegenwoordigt die opmaakinformatie levert. De GetFormat methode retourneert het NumberFormatInfo object dat numerieke opmaakinformatie biedt voor die cultuur.

• U kunt het werkelijke NumberFormatInfo object doorgeven dat numerieke opmaakgegevens biedt. (De implementatie van GetFormat alleen retourneert zichzelf.)

• U kunt een aangepast object doorgeven dat wordt geïmplementeerd IFormatProvider. De GetFormat methode instantieert en retourneert het NumberFormatInfo object dat opmaakinformatie biedt.

Als provider dat het is null, wordt de opmaak value geïnterpreteerd op basis van het NumberFormatInfo object van de huidige cultuur.

Zie ook

• TryParse

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

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

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

Parameters

Retouren

Een waarde die gelijk is aan het getal dat is opgegeven in de value parameter.

Uitzonderingen

Opmerkingen

De style parameter definieert de stijlelementen (zoals witruimte, het positieve of negatieve tekensymbool, het teken voor het groepsscheidingsteken of het decimale puntsymbool) die zijn toegestaan in de value parameter om de parseringsbewerking te laten slagen. styles moet een combinatie zijn van bitvlagmen uit de NumberStyles opsomming. De style parameter maakt deze methode overbelasting nuttig wanneer value de weergave van een hexadecimale waarde bevat, wanneer het getalsysteem (decimaal of hexadecimaal) dat wordt vertegenwoordigd door value alleen tijdens runtime bekend is, of wanneer u witruimte of een tekensymbool valuewilt weigeren.

Afhankelijk van de waarde van style, kan de value parameter de volgende elementen bevatten:

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

Als style dit is opgenomen NumberStyles.AllowHexSpecifier, kan de value parameter de volgende elementen bevatten:

[ws]hexdigits[ws]

Elementen in vierkante haken ([ en ]) zijn optioneel. In de volgende tabel wordt elk element beschreven.

Element	Beschrijving
Ws	Optionele witruimte. Witruimte kan aan het begin van value de NumberStyles.AllowLeadingWhitestyle vlag worden weergegeven en kan aan het einde van value de vlag worden weergegeven.styleNumberStyles.AllowTrailingWhite
$	Een cultuurspecifiek valutasymbool. De positie ervan value wordt gedefinieerd door de NumberFormatInfo.CurrencyNegativePattern en NumberFormatInfo.CurrencyPositivePattern eigenschappen van de cultuur die wordt aangegeven door de provider parameter. Het valutasymbool van de huidige cultuur kan worden weergegeven als valuestyle deze de NumberStyles.AllowCurrencySymbol vlag bevat.
ondertekenen	Een optioneel teken. Het teken kan aan het begin van value de vlag worden weergegeven als style deze de NumberStyles.AllowLeadingSign vlag bevat en kan worden weergegeven aan het einde van value de vlag.styleNumberStyles.AllowTrailingSign Haakjes kunnen worden gebruikt value om een negatieve waarde aan te geven als style deze de NumberStyles.AllowParentheses vlag bevat.
Cijfers fractional_digits exponential_digits	Een reeks cijfers van 0 tot en met 9. Voor fractional_digits is alleen het cijfer 0 geldig.
,	Een cultuurspecifiek groepsscheidingsteken. Het groepsscheidingsteken van de cultuur die is opgegeven door provider , kan worden weergegeven als valuestyle deze de NumberStyles.AllowThousands vlag bevat.
.	Een cultuurspecifiek decimaalteken. Het decimaalteken van de cultuur die door is provider aangewezen, kan worden weergegeven als valuestyle deze de NumberStyles.AllowDecimalPoint vlag bevat. Alleen het cijfer 0 kan worden weergegeven als een breukcijfer om de parseringsbewerking te laten slagen; als fractional_digits een ander cijfer bevat, wordt er een FormatException gegenereerd.
E	Het teken "e" of "E", dat aangeeft dat de waarde wordt weergegeven in exponentiële (wetenschappelijke) notatie. De value parameter kan een getal in exponentiële notatie vertegenwoordigen als style deze de NumberStyles.AllowExponent vlag bevat.
hexdigits	Een reeks hexadecimale cijfers van 0 tot en met f of 0 tot en met F.

Een value met alleen cijfers (die overeenkomt met de NumberStyles.None stijl) parseert altijd succesvol. De meeste resterende NumberStyles leden bepalen de elementen die aanwezig kunnen zijn, maar die niet aanwezig hoeven te zijn, in value. De volgende tabel geeft aan hoe afzonderlijke NumberStyles leden van invloed zijn op de elementen die aanwezig kunnen zijn in value.

NumberStyles-waarde	Elementen die naast cijfers in waarde zijn toegestaan
None	Alleen het cijferelement .
AllowDecimalPoint	De decimale puntelementen (.) en fractionele cijfers .
AllowExponent	Het teken "e" of "E", dat een exponentiële notatie aangeeft. samen met exponential_digits.
AllowLeadingWhite	Het ws-element aan het begin van value.
AllowTrailingWhite	Het ws-element aan het einde van value.
AllowLeadingSign	Het tekenelement aan het begin van value.
AllowTrailingSign	Het tekenelement aan het einde van value.
AllowParentheses	Het tekenelement in de vorm van haakjes tussen de numerieke waarde.
AllowThousands	Het groepsscheidingsteken (,) element.
AllowCurrencySymbol	Het valutaelement ($).
Currency	Alle elementen. value Kan echter geen hexadecimaal getal of een getal in exponentiële notatie vertegenwoordigen.
Float	Het ws-element aan het begin of einde van value, teken aan het begin van valueen het decimaalteken (.). De value parameter kan ook exponentiële notatie gebruiken.
Number	De wselementen , signgroepsscheidingsteken (,) en decimaalteken (.).
Any	Alle elementen. value Kan echter geen hexadecimaal getal vertegenwoordigen.

In tegenstelling tot de andere NumberStyles waarden, die wel de aanwezigheid van bepaalde stijlelementen valuevereisen, betekent de NumberStyles.AllowHexSpecifier stijlwaarde dat de afzonderlijke numerieke tekens value altijd worden geïnterpreteerd als hexadecimale tekens. Geldige hexadecimale tekens zijn 0-9, A-F en a-f. De enige andere vlaggen die kunnen worden gecombineerd met de style parameter zijn NumberStyles.AllowLeadingWhite en NumberStyles.AllowTrailingWhite. (De NumberStyles opsomming bevat een samengestelde getalstijl, HexNumberdie beide spatievlagmen bevat.)

De provider parameter is een IFormatProvider implementatie. De GetFormat methode retourneert een NumberFormatInfo object dat cultuurspecifieke informatie biedt over de indeling van value. provider Dit kan meestal een van de volgende zijn:

• Een CultureInfo object dat de cultuur vertegenwoordigt die numerieke opmaakgegevens biedt. De GetFormat methode retourneert het NumberFormatInfo object dat numerieke opmaakgegevens levert.

• Een NumberFormatInfo object dat opmaakinformatie biedt. (De implementatie van GetFormat alleen retourneert zichzelf.)

• Een aangepast object dat de methode implementeert IFormatProvider en gebruikt om het GetFormatNumberFormatInfo object te instantiëren en te retourneren dat opmaakinformatie biedt.

Als provider dat het is null, wordt het NumberFormatInfo object voor de huidige cultuur gebruikt.

Zie ook

• TryParse

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

Parameters

Retouren

Een waarde die gelijk is aan het getal dat is opgegeven in de value parameter.

Uitzonderingen

Voorbeelden

In het volgende voorbeeld worden verschillende aanroepen naar de Parse(String, NumberStyles, IFormatProvider) methode uitgevoerd met behulp van verschillende combinaties van waarden voor de style en provider parameters.

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

Een aantal afzonderlijke aanroepen naar de Parse(String, NumberStyles, IFormatProvider) methode geeft een exemplaar van de volgende BigIntegerFormatProvider klasse door, waarmee een tilde (~) wordt gedefinieerd als het negatieve teken.

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

Opmerkingen

De style parameter definieert de stijlelementen (zoals witruimte, het positieve of negatieve tekensymbool, het teken voor het groepsscheidingsteken of het decimale puntsymbool) die zijn toegestaan in de value parameter om de parseringsbewerking te laten slagen. styles moet een combinatie zijn van bitvlagmen uit de NumberStyles opsomming. De style parameter maakt deze methode overbelast wanneer value de tekenreeksweergave van een hexadecimale waarde bevat, wanneer het getalsysteem (decimaal of hexadecimaal) dat wordt vertegenwoordigd value door alleen tijdens runtime bekend is, of wanneer u witruimte of een tekensymbool valuewilt weigeren.

Afhankelijk van de waarde van style, kan de value parameter de volgende elementen bevatten:

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

Als style dit is opgenomen NumberStyles.AllowHexSpecifier, kan de value parameter de volgende elementen bevatten:

[ws]hexdigits[ws]

Elementen in vierkante haken ([ en ]) zijn optioneel. In de volgende tabel wordt elk element beschreven.

Element	Beschrijving
Ws	Optionele witruimte. Witruimte kan aan het begin van value de NumberStyles.AllowLeadingWhitestyle vlag worden weergegeven en kan aan het einde van value de vlag worden weergegeven.styleNumberStyles.AllowTrailingWhite
$	Een cultuurspecifiek valutasymbool. De positie in de tekenreeks wordt gedefinieerd door de NumberFormatInfo.CurrencyNegativePattern en NumberFormatInfo.CurrencyPositivePattern eigenschappen van de cultuur die wordt aangegeven door de provider parameter. Het valutasymbool van de huidige cultuur kan worden weergegeven als valuestyle deze de NumberStyles.AllowCurrencySymbol vlag bevat.
ondertekenen	Een optioneel teken. Het teken kan aan het begin van value de vlag worden weergegeven als style deze de NumberStyles.AllowLeadingSign vlag bevat en kan worden weergegeven aan het einde van value de vlag.styleNumberStyles.AllowTrailingSign Haakjes kunnen worden gebruikt value om een negatieve waarde aan te geven als style deze de NumberStyles.AllowParentheses vlag bevat.
Cijfers fractional_digits exponential_digits	Een reeks cijfers van 0 tot en met 9. Voor fractional_digits is alleen het cijfer 0 geldig.
,	Een cultuurspecifiek groepsscheidingsteken. Het groepsscheidingsteken van de cultuur die is opgegeven door provider , kan worden weergegeven als valuestyle deze de NumberStyles.AllowThousands vlag bevat.
.	Een cultuurspecifiek decimaalteken. Het decimaalteken van de cultuur die door is provider aangewezen, kan worden weergegeven als valuestyle deze de NumberStyles.AllowDecimalPoint vlag bevat. Alleen het cijfer 0 kan worden weergegeven als een breukcijfer om de parseringsbewerking te laten slagen; als fractional_digits een ander cijfer bevat, wordt er een FormatException gegenereerd.
E	Het teken "e" of "E", dat aangeeft dat de waarde wordt weergegeven in exponentiële (wetenschappelijke) notatie. De value parameter kan een getal in exponentiële notatie vertegenwoordigen als style deze de NumberStyles.AllowExponent vlag bevat.
hexdigits	Een reeks hexadecimale cijfers van 0 tot en met f of 0 tot en met F.

Een tekenreeks met alleen cijfers (die overeenkomt met de NumberStyles.None stijl) parseert altijd succesvol. De meeste resterende NumberStyles leden bepalen elementen die mogelijk aanwezig zijn, maar die niet aanwezig zijn, in de invoertekenreeks. De volgende tabel geeft aan hoe afzonderlijke NumberStyles leden van invloed zijn op de elementen die aanwezig kunnen zijn in value.

NumberStyles-waarde	Elementen die naast cijfers in waarde zijn toegestaan
None	Alleen het cijferelement .
AllowDecimalPoint	De decimale puntelementen (.) en fractionele cijfers .
AllowExponent	Het teken "e" of "E", dat een exponentiële notatie aangeeft. samen met exponential_digits.
AllowLeadingWhite	Het ws-element aan het begin van value.
AllowTrailingWhite	Het ws-element aan het einde van value.
AllowLeadingSign	Het tekenelement aan het begin van value.
AllowTrailingSign	Het tekenelement aan het einde van value.
AllowParentheses	Het tekenelement in de vorm van haakjes tussen de numerieke waarde.
AllowThousands	Het groepsscheidingsteken (,) element.
AllowCurrencySymbol	Het valutaelement ($).
Currency	Alle elementen. value Kan echter geen hexadecimaal getal of een getal in exponentiële notatie vertegenwoordigen.
Float	Het ws-element aan het begin of einde van value, teken aan het begin van valueen het decimaalteken (.). De value parameter kan ook exponentiële notatie gebruiken.
Number	De wselementen , signgroepsscheidingsteken (,) en decimaalteken (.).
Any	Alle elementen. value Kan echter geen hexadecimaal getal vertegenwoordigen.

In tegenstelling tot de andere NumberStyles waarden, die wel de aanwezigheid van bepaalde stijlelementen valuevereisen, betekent de NumberStyles.AllowHexSpecifier stijlwaarde dat de afzonderlijke numerieke tekens value altijd worden geïnterpreteerd als hexadecimale tekens. Geldige hexadecimale tekens zijn 0-9, A-F en a-f. De enige andere vlaggen die kunnen worden gecombineerd met de style parameter zijn NumberStyles.AllowLeadingWhite en NumberStyles.AllowTrailingWhite. (De NumberStyles opsomming bevat een samengestelde getalstijl, HexNumberdie beide spatievlagmen bevat.)

Als value een hexadecimale tekenreeks is, interpreteert value de Parse(String, NumberStyles) methode als een negatief getal dat is opgeslagen met behulp van de complementweergave van twee als de eerste twee hexadecimale cijfers groter zijn dan of gelijk zijn aan 0x80. Met andere woorden, de methode interpreteert de hoogste volgorde bit van de eerste byte in value als de teken-bit. Om ervoor te zorgen dat een hexadecimale tekenreeks correct wordt geïnterpreteerd als een positief getal, moet het eerste cijfer een value waarde van nul hebben. De methode interpreteert 0x80 bijvoorbeeld als een negatieve waarde, maar interpreteert een 0x080 of 0x0080 een positieve waarde. In het volgende voorbeeld ziet u het verschil tussen hexadecimale tekenreeksen die negatieve en positieve waarden vertegenwoordigen.

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.

De provider parameter is een IFormatProvider implementatie. De GetFormat methode retourneert een NumberFormatInfo object dat cultuurspecifieke informatie biedt over de indeling van value. provider Dit kan meestal een van de volgende zijn:

• Een CultureInfo object dat de cultuur vertegenwoordigt die numerieke opmaakgegevens biedt. De GetFormat methode retourneert het NumberFormatInfo object dat numerieke opmaakgegevens levert.

• Een NumberFormatInfo object dat opmaakinformatie biedt. (De implementatie van GetFormat alleen retourneert zichzelf.)

• Een aangepast object dat de methode implementeert IFormatProvider en gebruikt om het GetFormatNumberFormatInfo object te instantiëren en te retourneren dat opmaakinformatie biedt.

Als provider dat het is null, wordt het NumberFormatInfo object voor de huidige cultuur gebruikt.

Zie ook

• TryParse