UInt64.ToString Método

Source:

UInt64.cs

Source:

UInt64.cs

Source:

UInt64.cs

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

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

public string ToString (IFormatProvider provider);

public string ToString (IFormatProvider? provider);

override this.ToString : IFormatProvider -> string

Public Function ToString (provider As IFormatProvider) As String

Parámetros

Devoluciones

Representación en forma de cadena del valor de esta instancia, formada por una secuencia de dígitos que comprende del 0 al 9, sin signo y sin ceros a la izquierda.

Implementaciones

Ejemplos

En el ejemplo siguiente se da formato a un valor entero de 64 bits con signo mediante varios proveedores de formato, incluido uno para la referencia cultural invariable. La salida del ejemplo muestra que la cadena con formato devuelta por el ToString(IFormatProvider) método es la misma independientemente del proveedor de formato.

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 }; 
      ulong value = 18709243;
      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
//          18709243       18709243       18709243

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 = 18709243uL

printfn $"  {getName ci[0],12}   {getName ci[1],12}   {getName ci[2],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
//          18709243       18709243       18709243

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 ULong = 18709243
      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
'          18709243       18709243       18709243

Comentarios

El ToString(IFormatProvider) método da formato a un UInt64 valor en el formato predeterminado ("G" o general) mediante el NumberFormatInfo objeto de una referencia cultural especificada. Si desea especificar un formato diferente o la referencia cultural actual, use las demás sobrecargas del ToString método, como se indica a continuación:

El provider parámetro es una IFormatProvider implementación. Su GetFormat método devuelve un NumberFormatInfo objeto que proporciona información de formato específica de la referencia cultural. Sin embargo, ninguna de las propiedades de NumberFormatInfo se usa al dar formato con el especificador de formato numérico general ("G").

Consulte también

• Parse(String)
• Aplicar formato a tipos en .NET

Source:

UInt64.cs

Source:

UInt64.cs

Source:

UInt64.cs

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

public string ToString (string format);

public string ToString (string? format);

override this.ToString : string -> string

Public Function ToString (format As String) As String

Parámetros

Devoluciones

Representación en forma de cadena del valor de esta instancia, tal y como especifica format.

Excepciones

Ejemplos

En el ejemplo siguiente se muestra un valor entero de 64 bits sin signo mediante cada cadena de formato estándar y algunas cadenas de formato personalizado.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      ulong value = 217960834;
      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: 217960834
//       C: $217,960,834.00
//       D3: 217960834
//       E2: 2.18E+008
//       e3: 2.180e+008
//       F: 217960834.00
//       N: 217,960,834.00
//       P: 21,796,083,400.00 %
//       X: CFDD182
//       000000.0: 217960834.0
//       #.0: 217960834.0
//       00000000;(0);**Zero**: 217960834

let value = 217960834uL
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: 217960834
//       C: $217,960,834.00
//       D3: 217960834
//       E2: 2.18E+008
//       e3: 2.180e+008
//       F: 217960834.00
//       N: 217,960,834.00
//       P: 21,796,083,400.00 %
//       X: CFDD182
//       000000.0: 217960834.0
//       #.0: 217960834.0
//       00000000(0)**Zero**: 217960834

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim value As ULong = 217960834 
      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: 217960834
'       C: $217,960,834.00
'       D3: 217960834
'       E2: 2.18E+008
'       e3: 2.180e+008
'       F: 217960834.00
'       N: 217,960,834.00
'       P: 21,796,083,400.00 %
'       X: CFDD182
'       000000.0: 217960834.0
'       #.0: 217960834.0
'       00000000;(0);**Zero**: 217960834

Comentarios

El ToString(String) método da formato a un UInt64 valor en un formato especificado mediante un NumberFormatInfo objeto que representa las convenciones de la referencia cultural actual. Si desea usar el formato predeterminado ("G" o general) o especificar una referencia cultural diferente, use las demás sobrecargas del ToString método, como se indica a continuación:

El format parámetro puede ser cualquier cadena de formato numérico estándar válida o cualquier combinación de cadenas de formato numérico personalizado. Si format es igual a String.Empty o es null, el valor devuelto del objeto actual UInt64 tiene el formato del especificador de formato general ("G"). Si format es cualquier otro valor, el método produce un FormatException.

.NET proporciona una amplia compatibilidad con el formato, que se describe con más detalle en los temas de formato siguientes:

• Para obtener más información sobre los especificadores de formato numérico, vea Cadenas de formato numérico estándar y Cadenas de formato numérico personalizado.

• Para obtener más información sobre la compatibilidad con el formato en .NET, vea Formato de tipos.

El formato de la cadena devuelta viene determinado por el NumberFormatInfo objeto de la referencia cultural actual. Dependiendo del format parámetro , este objeto controla símbolos como el separador de grupo y el símbolo de separador decimal en la cadena de salida. Para proporcionar información de formato para referencias culturales distintas de la referencia cultural actual, llame a la ToString(String, IFormatProvider) sobrecarga.

Consulte también

• Parse(String)
• Aplicar formato a tipos en .NET
• Cómo: Rellenar un número con ceros a la izquierda

Source:

UInt64.cs

Source:

UInt64.cs

Source:

UInt64.cs

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

public string ToString (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

Parámetros

Devoluciones

Representación de cadena del valor de esta instancia, tal y como especifican format y provider.

Implementaciones

Excepciones

Ejemplos

En el ejemplo siguiente se muestra un valor entero de 32 bits sin signo mediante los especificadores de formato numérico estándar y una serie de objetos específicos CultureInfo .

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"};
      ulong value = 22224021;

      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:           22224021
//        G format using fr-FR culture:           22224021
//        G format using es-ES culture:           22224021
//
//        C format using en-US culture:     $22,224,021.00
//        C format using fr-FR culture:    22 224 021,00 €
//        C format using es-ES culture:    22.224.021,00 €
//
//       D4 format using en-US culture:           22224021
//       D4 format using fr-FR culture:           22224021
//       D4 format using es-ES culture:           22224021
//
//       E2 format using en-US culture:          2.22E+007
//       E2 format using fr-FR culture:          2,22E+007
//       E2 format using es-ES culture:          2,22E+007
//
//        F format using en-US culture:        22224021.00
//        F format using fr-FR culture:        22224021,00
//        F format using es-ES culture:        22224021,00
//
//        N format using en-US culture:      22,224,021.00
//        N format using fr-FR culture:      22 224 021,00
//        N format using es-ES culture:      22.224.021,00
//
//        P format using en-US culture: 2,222,402,100.00 %
//        P format using fr-FR culture: 2 222 402 100,00 %
//        P format using es-ES culture: 2.222.402.100,00 %
//
//       X2 format using en-US culture:            1531C95
//       X2 format using fr-FR culture:            1531C95
//       X2 format using es-ES culture:            1531C95

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 = 22224021uL

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:           22224021
//        G format using fr-FR culture:           22224021
//        G format using es-ES culture:           22224021
//
//        C format using en-US culture:     $22,224,021.00
//        C format using fr-FR culture:    22 224 021,00 €
//        C format using es-ES culture:    22.224.021,00 €
//
//       D4 format using en-US culture:           22224021
//       D4 format using fr-FR culture:           22224021
//       D4 format using es-ES culture:           22224021
//
//       E2 format using en-US culture:          2.22E+007
//       E2 format using fr-FR culture:          2,22E+007
//       E2 format using es-ES culture:          2,22E+007
//
//        F format using en-US culture:        22224021.00
//        F format using fr-FR culture:        22224021,00
//        F format using es-ES culture:        22224021,00
//
//        N format using en-US culture:      22,224,021.00
//        N format using fr-FR culture:      22 224 021,00
//        N format using es-ES culture:      22.224.021,00
//
//        P format using en-US culture: 2,222,402,100.00 %
//        P format using fr-FR culture: 2 222 402 100,00 %
//        P format using es-ES culture: 2.222.402.100,00 %
//
//       X2 format using en-US culture:            1531C95
//       X2 format using fr-FR culture:            1531C95
//       X2 format using es-ES culture:            1531C95

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 ULong = 22224021

      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:           22224021
'        G format using fr-FR culture:           22224021
'        G format using es-ES culture:           22224021
'
'        C format using en-US culture:     $22,224,021.00
'        C format using fr-FR culture:    22 224 021,00 €
'        C format using es-ES culture:    22.224.021,00 €
'
'       D4 format using en-US culture:           22224021
'       D4 format using fr-FR culture:           22224021
'       D4 format using es-ES culture:           22224021
'
'       E2 format using en-US culture:          2.22E+007
'       E2 format using fr-FR culture:          2,22E+007
'       E2 format using es-ES culture:          2,22E+007
'
'        F format using en-US culture:        22224021.00
'        F format using fr-FR culture:        22224021,00
'        F format using es-ES culture:        22224021,00
'
'        N format using en-US culture:      22,224,021.00
'        N format using fr-FR culture:      22 224 021,00
'        N format using es-ES culture:      22.224.021,00
'
'        P format using en-US culture: 2,222,402,100.00 %
'        P format using fr-FR culture: 2 222 402 100,00 %
'        P format using es-ES culture: 2.222.402.100,00 %
'
'       X2 format using en-US culture:            1531C95
'       X2 format using fr-FR culture:            1531C95
'       X2 format using es-ES culture:            1531C95

Comentarios

El ToString(String, IFormatProvider) método da formato a un UInt64 valor en un formato especificado mediante el NumberFormatInfo objeto de una referencia cultural especificada. Si desea usar la configuración predeterminada de formato o referencia cultural, use las demás sobrecargas del ToString método, como se indica a continuación:

El format parámetro puede ser cualquier cadena de formato numérico estándar válida o cualquier combinación de cadenas de formato numérico personalizado. Si format es igual a String.Empty o es null, el valor devuelto del objeto actual UInt64 tiene el formato del especificador de formato general ("G"). Si format es cualquier otro valor, el método produce un FormatException.

.NET proporciona una amplia compatibilidad con el formato, que se describe con más detalle en los temas de formato siguientes:

• Para obtener más información sobre los especificadores de formato numérico, vea Cadenas de formato numérico estándar y Cadenas de formato numérico personalizado.

• Para obtener más información sobre el formato, vea Tipos de formato.

El provider parámetro es una IFormatProvider implementación. Su GetFormat método devuelve un NumberFormatInfo objeto que proporciona información específica de la referencia cultural sobre el formato de la cadena devuelta por este método. Cuando se invoca el ToString(String, IFormatProvider) método , llama al provider método del IFormatProvider.GetFormat parámetro y lo pasa a un Type objeto que representa el NumberFormatInfo tipo. A GetFormat continuación, el método devuelve el NumberFormatInfo objeto que proporciona información para dar formato al valor actual UInt64 , como el símbolo separador de grupo o el símbolo decimal. Hay tres maneras de usar el provider parámetro para proporcionar información de formato al ToString(String, IFormatProvider) método :

• Puede pasar un CultureInfo objeto que represente la referencia cultural que proporciona información de formato. Su GetFormat método devuelve el NumberFormatInfo objeto que proporciona información de formato numérico para esa referencia cultural.

• Puede pasar el objeto real NumberFormatInfo que proporciona información de formato numérico. (Su implementación de GetFormat simplemente devuelve a sí mismo).

• Puede pasar un objeto personalizado que implemente IFormatProvider. Su GetFormat método crea una instancia y devuelve el NumberFormatInfo objeto que proporciona información de formato.

Si provider es null, el formato de la cadena devuelta se basa en el NumberFormatInfo objeto de la referencia cultural actual.

Consulte también

• Parse(String)
• Aplicar formato a tipos en .NET
• Cómo: Rellenar un número con ceros a la izquierda
• Ejemplo: Utilidad de formato WinForms de .NET Core (C#)
• Ejemplo: Utilidad de formato WinForms de .NET Core (Visual Basic)

Source:

UInt64.cs

Source:

UInt64.cs

Source:

UInt64.cs

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

public override string ToString ();

override this.ToString : unit -> string

Public Overrides Function ToString () As String

Devoluciones

Representación en forma de cadena del valor de esta instancia, formada por una secuencia de dígitos que comprende del 0 al 9, sin signo y sin ceros a la izquierda.

Ejemplos

En el ejemplo siguiente se muestra un UInt64 valor mediante el método predeterminado ToString() . También muestra las representaciones de cadena del UInt64 valor resultantes del uso de algunos especificadores de formato estándar. Los ejemplos se muestran mediante las convenciones de formato de la referencia cultural en-US.

using System;

public class Example
{
   public static void Main()
   {
      ulong value = 163249057;
      // 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:
//       163249057
//       
//       G format specifier:        163249057
//       C format specifier:  $163,249,057.00
//       D format specifier:        163249057
//       F format specifier:     163249057.00
//       N format specifier:   163,249,057.00
//       X format specifier:          9BAFBA1

let value = 163249057uL
// 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:
//       163249057
//       
//       G format specifier:        163249057
//       C format specifier:  $163,249,057.00
//       D format specifier:        163249057
//       F format specifier:     163249057.00
//       N format specifier:   163,249,057.00
//       X format specifier:          9BAFBA1

Module Example
   Public Sub Main()
      Dim value As ULong = 163249057
      ' 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:
'       163249057
'       
'       G format specifier:        163249057
'       C format specifier:  $163,249,057.00
'       D format specifier:        163249057
'       F format specifier:     163249057.00
'       N format specifier:   163,249,057.00
'       X format specifier:          9BAFBA1

Comentarios

El ToString() método da formato a un UInt64 valor en el formato predeterminado ("G" o general) mediante el NumberFormatInfo objeto de la referencia cultural actual. Si desea especificar otro formato o referencia cultural, use las demás sobrecargas del ToString método , como se indica a continuación:

Consulte también

• Parse(String)
• Aplicar formato a tipos en .NET