UInt32.ToString Metod

Definition

Namnområde:: System

Sammansättningar:: mscorlib.dll, System.Runtime.dll

Sammansättning:: mscorlib.dll

Sammansättning:: System.Runtime.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation.

Överlagringar

Name	Description
ToString(IFormatProvider)	Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation med den angivna kulturspecifika formatinformationen.
ToString(String, IFormatProvider)	Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation med det angivna formatet och den kulturspecifika formatinformationen.
ToString(String)	Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation med det angivna formatet.
ToString()	Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation.

ToString(IFormatProvider)

Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation med den angivna kulturspecifika formatinformationen.

public:
 virtual System::String ^ ToString(IFormatProvider ^ provider);

public:
 System::String ^ ToString(IFormatProvider ^ provider);

public string ToString(IFormatProvider provider);

override this.ToString : IFormatProvider -> string

Public Function ToString (provider As IFormatProvider) As String

Parametrar

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation.

Returer

String

Strängrepresentationen av värdet för den här instansen, som består av en sekvens med siffror mellan 0 och 9, utan tecken eller inledande nollor.

Implementeringar

ToString(IFormatProvider)

Exempel

I följande exempel formateras ett 16-bitars signerat heltalsvärde med hjälp av flera formatproviders, inklusive ett för den invarianta kulturen. Utdata från exemplet visar att den formaterade strängen ToString(IFormatProvider) som returneras av metoden är densamma oavsett formatprovider.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Define an array of CultureInfo objects.
      CultureInfo[] ci = { new CultureInfo("en-US"), 
                           new CultureInfo("fr-FR"), 
                           CultureInfo.InvariantCulture }; 
      uint value = 1870924;
      Console.WriteLine("  {0,12}   {1,12}   {2,12}", 
                        GetName(ci[0]), GetName(ci[1]), GetName(ci[2])); 
      Console.WriteLine("  {0,12}   {1,12}   {2,12}", 
                        value.ToString(ci[0]), value.ToString(ci[1]), value.ToString(ci[2]));   
   }

   private static string GetName(CultureInfo ci)
   {
      if (ci.Equals(CultureInfo.InvariantCulture))
         return "Invariant";
      else
         return ci.Name;         
   }
}
// The example displays the following output:
//             en-US          fr-FR      Invariant
//           1870924        1870924        1870924

open System.Globalization

let getName (ci: CultureInfo) =
    if ci.Equals CultureInfo.InvariantCulture then
        "Invariant"
    else
        ci.Name         

// Define an array of CultureInfo objects.
let ci = 
    [| CultureInfo "en-US" 
       CultureInfo "fr-FR"
       CultureInfo.InvariantCulture |]

let value = 1870924u

printfn $"  {getName ci[0],12}   {getName ci[1],12}   {getName ci[3],12}"
printfn $"  {value.ToString ci[0],12}   {value.ToString ci[1],12}   {value.ToString ci[2],12}"
// The example displays the following output:
//             en-US          fr-FR      Invariant
//           1870924        1870924        1870924

Imports System.Globalization

Module Example
   Public Sub Main()
      ' Define an array of CultureInfo objects.
      Dim ci() As CultureInfo = { New CultureInfo("en-US"), _
                                  New CultureInfo("fr-FR"), _
                                  CultureInfo.InvariantCulture } 
      Dim value As UInteger = 1870924
      Console.WriteLine("  {0,12}   {1,12}   {2,12}", _
                        GetName(ci(0)), GetName(ci(1)), GetName(ci(2))) 
      Console.WriteLine("  {0,12}   {1,12}   {2,12}", _
                        value.ToString(ci(0)), value.ToString(ci(1)), value.ToString(ci(2)))            
      
   End Sub
   
   Private Function GetName(ci As CultureInfo) As String
      If ci.Equals(CultureInfo.InvariantCulture) Then
         Return "Invariant"
      Else
         Return ci.Name
      End If   
   End Function
End Module
' The example displays the following output:
'        en-US          fr-FR      Invariant
'      1870924        1870924        1870924

Kommentarer

Metoden ToString(IFormatProvider) formaterar ett UInt32 värde i standardformatet ("G" eller allmänt) med hjälp av objektet för NumberFormatInfo en angiven kultur. Om du vill ange ett annat format eller den aktuella kulturen använder du de andra överlagringarna av ToString metoden enligt följande:

Så här använder du format	För kultur	Använd överlagringen
Standardformat ("G")	Standardkultur (aktuell)	ToString()
Ett specifikt format	Standardkultur (aktuell)	ToString(String)
Ett specifikt format	En specifik kultur	ToString(String, IFormatProvider)

Parametern provider är en IFormatProvider implementering. Dess GetFormat metod returnerar ett NumberFormatInfo objekt som tillhandahåller kulturspecifik formateringsinformation. Ingen av egenskaperna NumberFormatInfo för används dock vid formatering med den allmänna numeriska formatspecificeraren ("G").

Se även

Gäller för

ToString(String, IFormatProvider)

Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation med det angivna formatet och den kulturspecifika formatinformationen.

public:
 virtual System::String ^ ToString(System::String ^ format, IFormatProvider ^ provider);

public string ToString(string format, IFormatProvider provider);

override this.ToString : string * IFormatProvider -> string

Public Function ToString (format As String, provider As IFormatProvider) As String

Parametrar

format: String

En numerisk formatsträng.

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation om den här instansen.

Returer

String

Strängrepresentationen av värdet för den här instansen som anges av format och provider.

Implementeringar

ToString(String, IFormatProvider)

Undantag

FormatException

Parametern format är ogiltig.

Exempel

I följande exempel visas ett 32-bitars osignerat heltalsvärde med hjälp av standardnumreriska formatspecificerare och ett antal specifika CultureInfo objekt.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Define cultures whose formatting conventions are to be used.
      CultureInfo[] cultures = { CultureInfo.CreateSpecificCulture("en-US"), 
                                 CultureInfo.CreateSpecificCulture("fr-FR"), 
                                 CultureInfo.CreateSpecificCulture("es-ES") };
      string[] specifiers = {"G", "C", "D4", "E2", "F", "N", "P", "X2"}; 
      uint value = 2222402;
      
      foreach (string specifier in specifiers)
      {
         foreach (CultureInfo culture in cultures)
            Console.WriteLine("{0,2} format using {1} culture: {2, 18}",  
                              specifier, culture.Name, 
                              value.ToString(specifier, culture));
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//        G format using en-US culture:            2222402
//        G format using fr-FR culture:            2222402
//        G format using es-ES culture:            2222402
//       
//        C format using en-US culture:      $2,222,402.00
//        C format using fr-FR culture:     2 222 402,00 €
//        C format using es-ES culture:     2.222.402,00 €
//       
//       D4 format using en-US culture:            2222402
//       D4 format using fr-FR culture:            2222402
//       D4 format using es-ES culture:            2222402
//       
//       E2 format using en-US culture:          2.22E+006
//       E2 format using fr-FR culture:          2,22E+006
//       E2 format using es-ES culture:          2,22E+006
//       
//        F format using en-US culture:         2222402.00
//        F format using fr-FR culture:         2222402,00
//        F format using es-ES culture:         2222402,00
//       
//        N format using en-US culture:       2,222,402.00
//        N format using fr-FR culture:       2 222 402,00
//        N format using es-ES culture:       2.222.402,00
//       
//        P format using en-US culture:   222,240,200.00 %
//        P format using fr-FR culture:   222 240 200,00 %
//        P format using es-ES culture:   222.240.200,00 %
//       
//       X2 format using en-US culture:             21E942
//       X2 format using fr-FR culture:             21E942
//       X2 format using es-ES culture:             21E942

open System.Globalization

// Define cultures whose formatting conventions are to be used.
let cultures =
    [| CultureInfo.CreateSpecificCulture "en-US" 
       CultureInfo.CreateSpecificCulture "fr-FR" 
       CultureInfo.CreateSpecificCulture "es-ES" |]
let specifiers = 
    [| "G"; "C"; "D4"; "E2"; "F"; "N"; "P"; "X2" |] 
let value = 2222402

for specifier in specifiers do
    for culture in cultures do
        printfn $"{specifier,2} format using {culture.Name} culture: {value.ToString(specifier, culture), 18}"
    printfn ""
// The example displays the following output:
//        G format using en-US culture:            2222402
//        G format using fr-FR culture:            2222402
//        G format using es-ES culture:            2222402
//       
//        C format using en-US culture:      $2,222,402.00
//        C format using fr-FR culture:     2 222 402,00 €
//        C format using es-ES culture:     2.222.402,00 €
//       
//       D4 format using en-US culture:            2222402
//       D4 format using fr-FR culture:            2222402
//       D4 format using es-ES culture:            2222402
//       
//       E2 format using en-US culture:          2.22E+006
//       E2 format using fr-FR culture:          2,22E+006
//       E2 format using es-ES culture:          2,22E+006
//       
//        F format using en-US culture:         2222402.00
//        F format using fr-FR culture:         2222402,00
//        F format using es-ES culture:         2222402,00
//       
//        N format using en-US culture:       2,222,402.00
//        N format using fr-FR culture:       2 222 402,00
//        N format using es-ES culture:       2.222.402,00
//       
//        P format using en-US culture:   222,240,200.00 %
//        P format using fr-FR culture:   222 240 200,00 %
//        P format using es-ES culture:   222.240.200,00 %
//       
//       X2 format using en-US culture:             21E942
//       X2 format using fr-FR culture:             21E942
//       X2 format using es-ES culture:             21E942

Imports System.Globalization

Module Example
   Public Sub Main()
      ' Define cultures whose formatting conventions are to be used.
      Dim cultures() As CultureInfo = {CultureInfo.CreateSpecificCulture("en-US"), _
                                       CultureInfo.CreateSpecificCulture("fr-FR"), _
                                       CultureInfo.CreateSpecificCulture("es-ES") }
      Dim specifiers() As String = {"G", "C", "D4", "E2", "F", "N", "P", "X2"} 
      Dim value As UInteger = 2222402
      
      For Each specifier As String In specifiers
         For Each culture As CultureInfo In Cultures
            Console.WriteLine("{0,2} format using {1} culture: {2, 18}", _ 
                              specifier, culture.Name, _
                              value.ToString(specifier, culture))

         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'        G format using en-US culture:            2222402
'        G format using fr-FR culture:            2222402
'        G format using es-ES culture:            2222402
'       
'        C format using en-US culture:      $2,222,402.00
'        C format using fr-FR culture:     2 222 402,00 €
'        C format using es-ES culture:     2.222.402,00 €
'       
'       D4 format using en-US culture:            2222402
'       D4 format using fr-FR culture:            2222402
'       D4 format using es-ES culture:            2222402
'       
'       E2 format using en-US culture:          2.22E+006
'       E2 format using fr-FR culture:          2,22E+006
'       E2 format using es-ES culture:          2,22E+006
'       
'        F format using en-US culture:         2222402.00
'        F format using fr-FR culture:         2222402,00
'        F format using es-ES culture:         2222402,00
'       
'        N format using en-US culture:       2,222,402.00
'        N format using fr-FR culture:       2 222 402,00
'        N format using es-ES culture:       2.222.402,00
'       
'        P format using en-US culture:   222,240,200.00 %
'        P format using fr-FR culture:   222 240 200,00 %
'        P format using es-ES culture:   222.240.200,00 %
'       
'       X2 format using en-US culture:             21E942
'       X2 format using fr-FR culture:             21E942
'       X2 format using es-ES culture:             21E942

Kommentarer

Metoden ToString(String, IFormatProvider) formaterar ett UInt32 värde i ett angivet format med hjälp av objektet för NumberFormatInfo en angiven kultur. Om du vill använda standardformat- eller kulturinställningar använder du de andra överlagringarna av ToString metoden enligt följande:

Så här använder du format	För kultur	Använd överlagringen
Standardformat ("G")	Standardkultur (aktuell)	ToString()
Standardformat ("G")	En specifik kultur	ToString(IFormatProvider)
Ett specifikt format	Standardkultur (aktuell)	ToString(String)

Parametern format kan vara alla giltiga numeriska standardformatsträngar eller valfri kombination av anpassade numeriska formatsträngar. Om format är lika String.Empty med eller är nullformateras returvärdet för det aktuella UInt32 objektet med den allmänna formatspecificeraren ("G"). Om format är något annat värde genererar metoden en FormatException.

.NET ger omfattande formateringsstöd, vilket beskrivs mer detaljerat i följande formateringsämnen:

Mer information om numeriska formatspecificerare finns i Standard numeriska formatsträngar och anpassade numeriska formatsträngar.
Mer information om formatering finns i Formateringstyper.

Parametern provider är en IFormatProvider implementering. Metoden GetFormat returnerar ett NumberFormatInfo objekt som innehåller kulturspecifik information om formatet på strängen som returneras av den här metoden. ToString(String, IFormatProvider) När metoden anropas anropas provider parameterns IFormatProvider.GetFormat metod och skickar den ett Type objekt som representerar NumberFormatInfo typen. Metoden GetFormat returnerar sedan det NumberFormatInfo objekt som innehåller information för att formatera det aktuella UInt32 värdet, till exempel gruppavgränsarsymbolen eller decimaltecknet. Det finns tre sätt att använda parametern provider för att ange formateringsinformation till ToString(String, IFormatProvider) metoden:

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 nullbaseras formateringen för den returnerade strängen på objektet för NumberFormatInfo den aktuella kulturen.

Se även

Gäller för

ToString(String)

Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation med det angivna formatet.

public:
 System::String ^ ToString(System::String ^ format);

public string ToString(string format);

override this.ToString : string -> string

Public Function ToString (format As String) As String

Parametrar

format: String

En numerisk formatsträng.

Returer

String

Strängrepresentationen av värdet för den här instansen som anges av format.

Undantag

FormatException

Parametern format är ogiltig.

Exempel

I följande exempel visas ett 32-bitars osignerat heltalsvärde med hjälp av varje standardformatsträng och vissa anpassade formatsträngar.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      uint value = 2179608;
      string[] specifiers = { "G", "C", "D3", "E2", "e3", "F", 
                              "N", "P", "X", "000000.0", "#.0", 
                              "00000000;(0);**Zero**" };
      
      foreach (string specifier in specifiers)
         Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
   }
}
// The example displays the following output:
//       G: 2179608
//       C: $2,179,608.00
//       D3: 2179608
//       E2: 2.18E+006
//       e3: 2.180e+006
//       F: 2179608.00
//       N: 2,179,608.00
//       P: 217,960,800.00 %
//       X: 214218
//       000000.0: 2179608.0
//       #.0: 2179608.0
//       00000000;(0);**Zero**: 02179608

let value = 2179608u
let specifiers = 
    [| "G"; "C"; "D3"; "E2"; "e3"; "F" 
       "N"; "P"; "X"; "000000.0"; "#.0" 
       "00000000(0)**Zero**" |]

for specifier in specifiers do
    printfn $"{specifier}: {value.ToString specifier}"
// The example displays the following output:
//       G: 2179608
//       C: $2,179,608.00
//       D3: 2179608
//       E2: 2.18E+006
//       e3: 2.180e+006
//       F: 2179608.00
//       N: 2,179,608.00
//       P: 217,960,800.00 %
//       X: 214218
//       000000.0: 2179608.0
//       #.0: 2179608.0
//       00000000(0)**Zero**: 02179608

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim value As UInteger = 2179608 
      Dim specifiers() As String = { "G", "C", "D3", "E2", "e3", "F", _
                                     "N", "P", "X", "000000.0", "#.0", _
                                     "00000000;(0);**Zero**" }
      
      For Each specifier As String In specifiers
         Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
      Next
   End Sub
End Module
' The example displays the following output:
'       G: 2179608
'       C: $2,179,608.00
'       D3: 2179608
'       E2: 2.18E+006
'       e3: 2.180e+006
'       F: 2179608.00
'       N: 2,179,608.00
'       P: 217,960,800.00 %
'       X: 214218
'       000000.0: 2179608.0
'       #.0: 2179608.0
'       00000000;(0);**Zero**: 02179608

Kommentarer

Metoden ToString(String) formaterar ett UInt32 värde i ett angivet format med hjälp av ett NumberFormatInfo objekt som representerar den aktuella kulturens konventioner. Om du vill använda standardformatet ("G" eller allmänt) eller ange en annan kultur använder du de andra överlagringarna av ToString metoden enligt följande:

Så här använder du format	För kultur	Använd överlagringen
Standardformat ("G")	Standardkultur (aktuell)	ToString()
Standardformat ("G")	En specifik kultur	ToString(IFormatProvider)
Ett specifikt format	En specifik kultur	ToString(String, IFormatProvider)

.NET ger omfattande formateringsstöd, vilket beskrivs mer detaljerat i följande formateringsämnen:

Mer information om numeriska formatspecificerare finns i Standard numeriska formatsträngar och anpassade numeriska formatsträngar.
Mer information om stöd för formatering i .NET finns i Formateringstyper.

Formatet för den returnerade strängen NumberFormatInfo bestäms av objektet för den aktuella kulturen. Beroende på parametern format styr det här objektet symboler som gruppavgränsaren och decimaltecknet i utdatasträngen. Om du vill ange formateringsinformation för andra kulturer än den aktuella kulturen anropar du överlagringen ToString(String, IFormatProvider) .

Se även

Gäller för

ToString()

Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation.

public:
 override System::String ^ ToString();

public override string ToString();

override this.ToString : unit -> string

Public Overrides Function ToString () As String

Returer

String

Strängrepresentationen av värdet för den här instansen, som består av en sekvens med siffror mellan 0 och 9, utan tecken eller inledande nollor.

Exempel

I följande exempel visas ett UInt32 värde med hjälp av standardmetoden ToString() . Den visar också strängrepresentationer av värdet UInt32 som resulterar från att använda vissa standardformatsspecificerare. Exemplen visas med formateringskonventionerna för en-US kultur.

using System;

public class Example
{
   public static void Main()
   {
      uint value = 1632490;
      // Display value using default ToString method.
      Console.WriteLine(value.ToString());      
      Console.WriteLine();
      
      // Define an array of format specifiers.
      string[] formats = { "G", "C", "D", "F", "N", "X" };
      // Display value using the standard format specifiers.
      foreach (string format in formats)
         Console.WriteLine("{0} format specifier: {1,16}", 
                           format, value.ToString(format));         
   }
}
// The example displays the following output:
//       1632490
//       
//       G format specifier:          1632490
//       C format specifier:    $1,632,490.00
//       D format specifier:          1632490
//       F format specifier:       1632490.00
//       N format specifier:     1,632,490.00
//       X format specifier:           18E8EA

let value = 1632490u
// Display value using default ToString method.
printfn $"{value.ToString()}\n"      

// Define an array of format specifiers.
let formats = [| "G"; "C"; "D"; "F"; "N"; "X" |]
// Display value using the standard format specifiers.
for format in formats do
    printfn $"{format} format specifier: {value.ToString format,16}"
// The example displays the following output:
//       1632490
//       
//       G format specifier:          1632490
//       C format specifier:    $1,632,490.00
//       D format specifier:          1632490
//       F format specifier:       1632490.00
//       N format specifier:     1,632,490.00
//       X format specifier:           18E8EA

Module Example
   Public Sub Main()
      Dim value As UInteger = 1632490
      ' Display value using default ToString method.
      Console.WriteLine(value.ToString())            
      Console.WriteLine()
      
      ' Define an array of format specifiers.
      Dim formats() As String = { "G", "C", "D", "F", "N", "X" }
      ' Display value using the standard format specifiers.
      For Each format As String In formats
         Console.WriteLine("{0} format specifier: {1,16}", _
                           format, value.ToString(format))         
      Next
   End Sub
End Module
' The example displays the following output:
'       1632490
'       
'       G format specifier:          1632490
'       C format specifier:    $1,632,490.00
'       D format specifier:          1632490
'       F format specifier:       1632490.00
'       N format specifier:     1,632,490.00
'       X format specifier:           18E8EA

Kommentarer

Metoden ToString() formaterar ett UInt32 värde i standardformatet ("G" eller allmänt) med hjälp NumberFormatInfo av objektet i den aktuella kulturen. Om du vill ange ett annat format eller en annan kultur använder du de andra överlagringarna av ToString metoden enligt följande:

Så här använder du format	För kultur	Använd överlagringen
Standardformat ("G")	En specifik kultur	ToString(IFormatProvider)
Ett specifikt format	Standardkultur (aktuell)	ToString(String)
Ett specifikt format	En specifik kultur	ToString(String, IFormatProvider)

Se även

Gäller för

Feedback

Var den här sidan till hjälp?