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

En IFormatProvider som tillhandahåller kulturspecifik formateringsinformation.

Returer

String

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

Implementeringar

ToString(IFormatProvider)

Exempel

I följande exempel visas strängrepresentationen av ett Int64 värde med hjälp av CultureInfo objekt som representerar flera olika kulturer.

long value = -16325901;
// Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture));
// Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")));
// Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")));
// This example displays the following output to the console:
//       -16325901
//       -16325901
//       -16325901

let value = -16325901L
// Display value using the invariant culture.
printfn $"{value.ToString CultureInfo.InvariantCulture}"
// Display value using the en-GB culture.
printfn $"""{value.ToString(CultureInfo.CreateSpecificCulture "en-GB" )}"""
// Display value using the de-DE culture.
printfn $"""{value.ToString(CultureInfo.CreateSpecificCulture "de-DE" )}"""
// This example displays the following output to the console:
//       -16325901
//       -16325901
//       -16325901

Dim value As Long = -16325801
' Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture))
' Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")))
' Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")))
' This example displays the following output to the console:
'       -16325901
'       -16325901
'       -16325901

Kommentarer

Metoden ToString(IFormatProvider) formaterar ett Int64 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 ett objekt som implementerar IFormatProvider gränssnittet. Metoden GetFormat returnerar ett NumberFormatInfo objekt som innehåller kulturspecifik information om formatet på strängen som returneras av den här metoden. Objektet som implementerar IFormatProvider kan vara något av följande:

Ett CultureInfo objekt som representerar kulturen vars formateringsregler ska användas.
Ett NumberFormatInfo objekt som innehåller specifik numerisk formateringsinformation för det här värdet.
Ett anpassat objekt som implementerar IFormatProvider och vars GetFormat metod returnerar ett NumberFormatInfo objekt som tillhandahåller formateringsinformation.

Om provider is null eller ett NumberFormatInfo objekt inte kan hämtas från providerformateras returvärdet med NumberFormatInfo objektet för den aktuella kulturen.

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

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

format är ogiltigt eller stöds inte.

Exempel

I följande exempel visas ett positivt och ett negativt värde med var och en av de standardnumreriska standardformatsspecificerarna för tre olika kulturer.

// Define cultures whose formatting conventions are to be used.
CultureInfo[] cultures = {CultureInfo.CreateSpecificCulture("en-US"),
                          CultureInfo.CreateSpecificCulture("fr-FR"),
                          CultureInfo.CreateSpecificCulture("es-ES") };
long positiveNumber = 1679;
long negativeNumber = -3045;
string[] specifiers = {"G", "C", "D8", "E2", "F", "N", "N0", "P", "X8"};

foreach (string specifier in specifiers)
{
   foreach (CultureInfo culture in cultures)
   {
      // Display values with "G" format specifier.
      Console.WriteLine("{0} format using {1} culture: {2, 16} {3, 16}",
                        specifier, culture.Name,
                        positiveNumber.ToString(specifier, culture),
                        negativeNumber.ToString(specifier, culture));
   }
   Console.WriteLine();
}
// The example displays the following output to the console:
//    G format using en-US culture:             1679            -3045
//    G format using fr-FR culture:             1679            -3045
//    G format using es-ES culture:             1679            -3045
//
//    C format using en-US culture:        $1,679.00      ($3,045.00)
//    C format using fr-FR culture:       1 679,00 €      -3 045,00 €
//    C format using es-ES culture:       1.679,00 €      -3.045,00 €
//
//    D8 format using en-US culture:         00001679        -00003045
//    D8 format using fr-FR culture:         00001679        -00003045
//    D8 format using es-ES culture:         00001679        -00003045
//
//    E2 format using en-US culture:        1.68E+003       -3.05E+003
//    E2 format using fr-FR culture:        1,68E+003       -3,05E+003
//    E2 format using es-ES culture:        1,68E+003       -3,05E+003
//
//    F format using en-US culture:          1679.00         -3045.00
//    F format using fr-FR culture:          1679,00         -3045,00
//    F format using es-ES culture:          1679,00         -3045,00
//
//    N format using en-US culture:         1,679.00        -3,045.00
//    N format using fr-FR culture:         1 679,00        -3 045,00
//    N format using es-ES culture:         1.679,00        -3.045,00
//
//    N0 format using en-US culture:         1,679           -3,045
//    N0 format using fr-FR culture:         1 679           -3 045
//    N0 format using es-ES culture:         1.679           -3.045
//
//    P format using en-US culture:      167,900.00%     -304,500.00%
//    P format using fr-FR culture:     167 900,00 %    -304 500,00 %
//    P format using es-ES culture:     167.900,00 %    -304.500,00 %
//
//    X8 format using en-US culture:         0000068F FFFFFFFFFFFFF41B
//    X8 format using fr-FR culture:         0000068F FFFFFFFFFFFFF41B
//    X8 format using es-ES culture:         0000068F FFFFFFFFFFFFF41B

// Define cultures whose formatting conventions are to be used.
let cultures = 
    [| CultureInfo.CreateSpecificCulture "en-US"
       CultureInfo.CreateSpecificCulture "fr-FR"
       CultureInfo.CreateSpecificCulture "es-ES" |]

let positiveNumber = 1679L
let negativeNumber = -3045L
let specifiers = [| "G"; "C"; "D8"; "E2"; "F"; "N"; "N0"; "P"; "X8" |]

for specifier in specifiers do
    for culture in cultures do
        // Display values with "G" format specifier.
        printfn $"{specifier} format using {culture.Name} culture: {positiveNumber.ToString(specifier, culture), 16} {negativeNumber.ToString(specifier, culture), 16}"           
    printfn ""

// The example displays the following output to the console:
//    G format using en-US culture:             1679            -3045
//    G format using fr-FR culture:             1679            -3045
//    G format using es-ES culture:             1679            -3045
//
//    C format using en-US culture:        $1,679.00      ($3,045.00)
//    C format using fr-FR culture:       1 679,00 €      -3 045,00 €
//    C format using es-ES culture:       1.679,00 €      -3.045,00 €
//
//    D8 format using en-US culture:         00001679        -00003045
//    D8 format using fr-FR culture:         00001679        -00003045
//    D8 format using es-ES culture:         00001679        -00003045
//
//    E2 format using en-US culture:        1.68E+003       -3.05E+003
//    E2 format using fr-FR culture:        1,68E+003       -3,05E+003
//    E2 format using es-ES culture:        1,68E+003       -3,05E+003
//
//    F format using en-US culture:          1679.00         -3045.00
//    F format using fr-FR culture:          1679,00         -3045,00
//    F format using es-ES culture:          1679,00         -3045,00
//
//    N format using en-US culture:         1,679.00        -3,045.00
//    N format using fr-FR culture:         1 679,00        -3 045,00
//    N format using es-ES culture:         1.679,00        -3.045,00
//
//    N0 format using en-US culture:         1,679           -3,045
//    N0 format using fr-FR culture:         1 679           -3 045
//    N0 format using es-ES culture:         1.679           -3.045
//
//    P format using en-US culture:      167,900.00%     -304,500.00%
//    P format using fr-FR culture:     167 900,00 %    -304 500,00 %
//    P format using es-ES culture:     167.900,00 %    -304.500,00 %
//
//    X8 format using en-US culture:         0000068F FFFFFFFFFFFFF41B
//    X8 format using fr-FR culture:         0000068F FFFFFFFFFFFFF41B
//    X8 format using es-ES culture:         0000068F FFFFFFFFFFFFF41B

' 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 positiveNumber As Long = 1679
Dim negativeNumber As Long = -3045
Dim specifiers() As String = {"G", "C", "D8", "E2", "F", "N", "P", "X8"} 

For Each specifier As String In specifiers
   For Each culture As CultureInfo In Cultures
      ' Display values with "G" format specifier.
      Console.WriteLine("{0} format using {1} culture: {2, 16} {3, 16}", _ 
                        specifier, culture.Name, _
                        positiveNumber.ToString(specifier, culture), _
                        negativeNumber.ToString(specifier, culture))

   Next
   Console.WriteLine()
Next
' The example displays the following output to the console:
'
'    G format using en-US culture:             1679            -3045
'    G format using fr-FR culture:             1679            -3045
'    G format using es-ES culture:             1679            -3045
'
'    C format using en-US culture:        $1,679.00      ($3,045.00)
'    C format using fr-FR culture:       1 679,00 €      -3 045,00 €
'    C format using es-ES culture:       1.679,00 €      -3.045,00 €
'
'    D8 format using en-US culture:         00001679        -00003045
'    D8 format using fr-FR culture:         00001679        -00003045
'    D8 format using es-ES culture:         00001679        -00003045
'
'    E2 format using en-US culture:        1.68E+003       -3.05E+003
'    E2 format using fr-FR culture:        1,68E+003       -3,05E+003
'    E2 format using es-ES culture:        1,68E+003       -3,05E+003
'
'    F format using en-US culture:          1679.00         -3045.00
'    F format using fr-FR culture:          1679,00         -3045,00
'    F format using es-ES culture:          1679,00         -3045,00
'
'    N format using en-US culture:         1,679.00        -3,045.00
'    N format using fr-FR culture:         1 679,00        -3 045,00
'    N format using es-ES culture:         1.679,00        -3.045,00
'
'    P format using en-US culture:      167,900.00%     -304,500.00%
'    P format using fr-FR culture:     167 900,00 %    -304 500,00 %
'    P format using es-ES culture:     167.900,00 %    -304.500,00 %
'
'    X8 format using en-US culture:         0000068F FFFFFFFFFFFFF41B
'    X8 format using fr-FR culture:         0000068F FFFFFFFFFFFFF41B
'    X8 format using es-ES culture:         0000068F FFFFFFFFFFFFF41B

Kommentarer

Metoden ToString(String, IFormatProvider) formaterar ett Int64 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 antingen en standardsträng eller en anpassad numerisk formatsträng. Alla numeriska standardformatsträngar förutom "R" (eller "r") stöds, liksom alla anpassade numeriska formattecken. Om format är null eller en tom sträng (") formateras returvärdet för den här instansen med den allmänna numeriska formatspecificeraren ("G").

Ett CultureInfo objekt som representerar kulturen vars formateringsregler ska användas.
Ett NumberFormatInfo objekt som innehåller specifik numerisk formateringsinformation för det här värdet.
Ett anpassat objekt som implementerar IFormatProvider och vars GetFormat metod returnerar ett NumberFormatInfo objekt som tillhandahåller formateringsinformation.

Om provider is null eller ett NumberFormatInfo objekt inte kan hämtas från providerformateras returvärdet för den här instansen NumberFormatInfo med för den aktuella kulturen.

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

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

format är ogiltigt eller stöds inte.

Exempel

I följande exempel visas ett värde som använder var och en Int64 av de numeriska standardformatsspecificerarna tillsammans med två anpassade numeriska formatsträngar. När du konverterar de numeriska värdena till strängar använder exemplet formateringskonventionerna i en-US kultur.

long value = -16325;
string specifier;

// Use standard numeric format specifier.
specifier = "G";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    G: -16325
specifier = "C";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    C: ($16,325.00)
specifier = "D8";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    D8: -00016325
specifier = "E4";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    E4: -1.6325E+004
specifier = "e3";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    e3: -1.633e+004
specifier = "F";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    F: -16325.00
specifier = "N";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    N: -16,325.00
specifier = "P";
Console.WriteLine("{0}: {1}", specifier, (value/100000.0).ToString(specifier));
// Displays:    P: -16.33 %
specifier = "X";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    X: FFFFFFFFFFFFC03B

// Use custom numeric format specifiers.
specifier = "0,0.000";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    0,0.000: -16,325.000
specifier = "#,#.00#;(#,#.00#)";
Console.WriteLine("{0}: {1}", specifier, (value*-1).ToString(specifier));
// Displays:    #,#.00#;(#,#.00#): 16,325.00

let value = -16325L

// Use standard numeric format specifier.
let specifier = "G"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    G: -16325

let specifier = "C"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    C: ($16,325.00)

let specifier = "D8"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    D8: -00016325

let specifier = "E4"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    E4: -1.6325E+004

let specifier = "e3"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    e3: -1.633e+004

let specifier = "F"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    F: -16325.00

let specifier = "N"
printfn $"{specifier}: {value.ToString specifier }"
// Displays:    N: -16,325.00

let specifier = "P"
printfn $"{specifier}: {(float value / 100000.0).ToString specifier}"
// Displays:    P: -16.33 %

let specifier = "X"
printfn $"{specifier}: {value.ToString(specifier)}"
// Displays:    X: FFFFFFFFFFFFC03B

// Use custom numeric format specifiers.
let specifier = "0,0.000"
printfn $"{specifier}: {value.ToString(specifier)}"
// Displays:    0,0.000: -16,325.000

let specifier = "#,#.00#(#,#.00#)"
printfn $"{specifier}: {(value * -1L).ToString specifier}"
// Displays:    #,#.00#(#,#.00#): 16,325.00

Dim value As Long = -16325
Dim specifier As String

' Use standard numeric format specifier.
specifier = "G"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    G: -16325
specifier = "C"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    C: ($16,325.00)
specifier = "D8"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    D8: -00016325
specifier = "E4"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    E4: -1.6325E+004
specifier = "e3"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    e3: -1.633e+004
specifier = "F"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    F: -16325.00
specifier = "N"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    N: -16,325.00
specifier = "P"
Console.WriteLine("{0}: {1}", specifier, (value/100000).ToString(specifier))
' Displays:    P: -16.33 %
specifier = "X"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    X: FFFFFFFFFFFFC03B

' Use custom numeric format specifiers.
specifier = "0,0.000"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    0,0.000: -16,325.000
specifier = "#,#.00#;(#,#.00#)"
Console.WriteLine("{0}: {1}", specifier, (value*-1).ToString(specifier))
' Displays:    #,#.00#;(#,#.00#): 16,325.00

Kommentarer

Metoden ToString(String) formaterar ett Int64 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)

Parametern format kan vara valfritt giltigt numeriskt standardformatsspecificerare förutom "R", samt valfri kombination av anpassade numeriska formatspecificerare. Om format är null eller en tom sträng (") formateras returvärdet för den här instansen med den allmänna numeriska formatspecificeraren ("G").

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

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

Returvärdet för den här instansen NumberFormatInfo formateras med för den aktuella kulturen.

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 ett minustecken om värdet är negativt, och en sekvens med siffror mellan 0 och 9 utan inledande nollor.

Exempel

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

long value = -16325091;
// Display value using default ToString method.
Console.WriteLine(value.ToString());            // Displays -16325091
// Display value using some standard format specifiers.
Console.WriteLine(value.ToString("G"));         // Displays -16325091
Console.WriteLine(value.ToString("C"));         // Displays ($16,325,091.00)
Console.WriteLine(value.ToString("D"));         // Displays -16325091
Console.WriteLine(value.ToString("F"));         // Displays -16325091.00
Console.WriteLine(value.ToString("N"));         // Displays -16,325,091.00
Console.WriteLine(value.ToString("N0"));         // Displays -16,325,091
Console.WriteLine(value.ToString("X"));         // Displays FFFFFFFFFF06E61D

let value = -16325091L
// Display value using default ToString method.
printfn $"{value.ToString()}"            // Displays -16325091
// Display value using some standard format specifiers.
printfn $"""{value.ToString "G"}"""         // Displays -16325091
printfn $"""{value.ToString "C"}"""         // Displays ($16,325,091.00)
printfn $"""{value.ToString "D"}"""         // Displays -16325091
printfn $"""{value.ToString "F"}"""         // Displays -16325091.00
printfn $"""{value.ToString "N"}"""         // Displays -16,325,091.00
printfn $"""{value.ToString "N0"}"""        // Displays -16,325,091
printfn $"""{value.ToString "X"}"""         // Displays FFFFFFFFFF06E61D

Dim value As Long = -16325091
' Display value using default ToString method.
Console.WriteLine(value.ToString())            ' Displays -16325091
' Display value using some standard format specifiers.
Console.WriteLine(value.ToString("G"))         ' Displays -16325091
Console.WriteLine(value.ToString("C"))         ' Displays ($16,325,091.00)
Console.WriteLine(value.ToString("D"))         ' Displays -16325091
Console.WriteLine(value.ToString("F"))         ' Displays -16325091.00
Console.WriteLine(value.ToString("N"))         ' Displays -16,325091.00
Console.WriteLine(value.ToString("X"))         ' Displays FFFFFFFFFF06E61D

Kommentarer

Metoden ToString() formaterar ett Int64 värde i standardformatet ("G" eller allmänt) med hjälp NumberFormatInfo av objektet för 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)

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

Se även

Gäller för

Feedback

Var den här sidan till hjälp?