UInt16.ToString Metodo

Origine:

UInt16.cs

Origine:

UInt16.cs

Origine:

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

Parametri

Restituisce

Rappresentazione di stringa del valore di questa istanza, composto da una sequenza di cifre comprese tra 0 e 9 senza segno o zeri iniziali.

Implementazioni

Esempio

Nell'esempio seguente viene formattato un valore intero con segno a 16 bit usando diversi provider di formato, tra cui uno per le impostazioni cultura invarianti. L'output dell'esempio illustra che la stringa formattata restituita dal ToString(IFormatProvider) metodo è la stessa indipendentemente dal provider di 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 }; 
      UInt16 value = 18924;
      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
//          18924          18924          18924

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 = 18924us
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
//          18924          18924          18924

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 UInt16 = 18924
      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
'         18924          18924          18924

Commenti

Il ToString(IFormatProvider) metodo formatta un UInt16 valore nel formato predefinito ("G" o generale) usando l'oggetto NumberFormatInfo di impostazioni cultura specificate. Se si desidera specificare un formato diverso o le impostazioni cultura correnti, usare gli altri overload del ToString metodo, come indicato di seguito:

Il provider parametro è un'implementazione IFormatProvider . Il metodo GetFormat restituisce un NumberFormatInfo oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura. Tuttavia, nessuna delle proprietà di NumberFormatInfo viene utilizzata durante la formattazione con l'identificatore di formato numerico generale ("G").

Vedi anche

• Parse(String)
• Formattazione di tipi in .NET

Origine:

UInt16.cs

Origine:

UInt16.cs

Origine:

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

Parametri

Restituisce

Rappresentazione di stringa del valore dell'istanza, in base a quanto specificato da format.

Eccezioni

Esempio

Nell'esempio seguente viene visualizzato un valore intero senza segno a 16 bit usando ogni stringa di formato standard e alcune stringhe di formato personalizzate.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      ushort value = 21708;
      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: 21708
//       C: $21,708.00
//       D3: 21708
//       E2: 2.17E+004
//       e3: 2.171e+004
//       F: 21708.00
//       N: 21,708.00
//       P: 2,170,800.00 %
//       X: 54CC
//       000000.0: 021708.0
//       #.0: 21708.0
//       00000000;(0);**Zero**: 00021708

let value = 21708us
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: 21708
//       C: $21,708.00
//       D3: 21708
//       E2: 2.17E+004
//       e3: 2.171e+004
//       F: 21708.00
//       N: 21,708.00
//       P: 2,170,800.00 %
//       X: 54CC
//       000000.0: 021708.0
//       #.0: 21708.0
//       00000000(0)**Zero**: 00021708

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim value As UShort = 21708 
      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: 21708
'       C: $21,708.00
'       D3: 21708
'       E2: 2.17E+004
'       e3: 2.171e+004
'       F: 21708.00
'       N: 21,708.00
'       P: 2,170,800.00 %
'       X: 54CC
'       000000.0: 021708.0
'       #.0: 21708.0
'       00000000;(0);**Zero**: 00021708

Commenti

Il ToString(String) metodo formatta un UInt16 valore in un formato specificato utilizzando un NumberFormatInfo oggetto che rappresenta le convenzioni delle impostazioni cultura correnti. Se si desidera usare il formato predefinito ("G" o generale) o specificare impostazioni cultura diverse, usare gli altri overload del ToString metodo, come indicato di seguito:

Il format parametro può essere qualsiasi identificatore di formato numerico standard valido o qualsiasi combinazione di identificatori di formato numerico personalizzato. Se format è uguale a String.Empty o è null, il valore restituito dell'oggetto corrente UInt16 viene formattato con l'identificatore di formato generale ("G"). Se format è un altro valore, il metodo genera un oggetto FormatException.

.NET offre un supporto completo per la formattazione, descritto in modo più dettagliato negli argomenti di formattazione seguenti:

• Per altre informazioni sugli identificatori di formato numerico, vedere Stringhe di formato numerico standard e stringhe di formato numerico personalizzato.

• Per altre informazioni sul supporto per la formattazione in .NET, vedere Formattazione dei tipi.

Il formato della stringa restituita è determinato dall'oggetto NumberFormatInfo per le impostazioni cultura correnti. A seconda del format parametro, questo oggetto controlla i simboli, ad esempio il separatore di gruppo e il simbolo di virgola decimale nella stringa di output. Per fornire informazioni di formattazione per impostazioni cultura diverse dalle impostazioni cultura correnti, chiamare l'overload ToString(String, IFormatProvider) .

Vedi anche

• Parse(String)
• Formattazione di tipi in .NET
• Procedura: aggiungere zeri iniziali a un numero

Origine:

UInt16.cs

Origine:

UInt16.cs

Origine:

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

Parametri

Restituisce

Rappresentazione di stringa del valore dell'istanza corrente, in base a quanto specificato da format e provider.

Implementazioni

Eccezioni

Esempio

Nell'esempio seguente viene visualizzato un valore intero senza segno a 16 bit usando gli identificatori di formato numerico standard e un numero di oggetti specifici 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"}; 
      ushort value = 22042;
      
      foreach (string specifier in specifiers)
      {
         foreach (CultureInfo culture in cultures)
            Console.WriteLine("{0,2} format using {1} culture: {2, 16}",  
                              specifier, culture.Name, 
                              value.ToString(specifier, culture));
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//        G format using en-US culture:            22042
//        G format using fr-FR culture:            22042
//        G format using es-ES culture:            22042
//       
//        C format using en-US culture:       $22,042.00
//        C format using fr-FR culture:      22 042,00 €
//        C format using es-ES culture:      22.042,00 €
//       
//       D4 format using en-US culture:            22042
//       D4 format using fr-FR culture:            22042
//       D4 format using es-ES culture:            22042
//       
//       E2 format using en-US culture:        2.20E+004
//       E2 format using fr-FR culture:        2,20E+004
//       E2 format using es-ES culture:        2,20E+004
//       
//        F format using en-US culture:         22042.00
//        F format using fr-FR culture:         22042,00
//        F format using es-ES culture:         22042,00
//       
//        N format using en-US culture:        22,042.00
//        N format using fr-FR culture:        22 042,00
//        N format using es-ES culture:        22.042,00
//       
//        P format using en-US culture:   2,204,200.00 %
//        P format using fr-FR culture:   2 204 200,00 %
//        P format using es-ES culture:   2.204.200,00 %
//       
//       X2 format using en-US culture:             561A
//       X2 format using fr-FR culture:             561A
//       X2 format using es-ES culture:             561A

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 = 22042us

for specifier in specifiers do
    for culture in cultures do
        printfn $"{specifier,2} format using {culture.Name} culture: {value.ToString(specifier, culture), 16}"
    printfn ""
// The example displays the following output:
//        G format using en-US culture:            22042
//        G format using fr-FR culture:            22042
//        G format using es-ES culture:            22042
//       
//        C format using en-US culture:       $22,042.00
//        C format using fr-FR culture:      22 042,00 €
//        C format using es-ES culture:      22.042,00 €
//       
//       D4 format using en-US culture:            22042
//       D4 format using fr-FR culture:            22042
//       D4 format using es-ES culture:            22042
//       
//       E2 format using en-US culture:        2.20E+004
//       E2 format using fr-FR culture:        2,20E+004
//       E2 format using es-ES culture:        2,20E+004
//       
//        F format using en-US culture:         22042.00
//        F format using fr-FR culture:         22042,00
//        F format using es-ES culture:         22042,00
//       
//        N format using en-US culture:        22,042.00
//        N format using fr-FR culture:        22 042,00
//        N format using es-ES culture:        22.042,00
//       
//        P format using en-US culture:   2,204,200.00 %
//        P format using fr-FR culture:   2 204 200,00 %
//        P format using es-ES culture:   2.204.200,00 %
//       
//       X2 format using en-US culture:             561A
//       X2 format using fr-FR culture:             561A
//       X2 format using es-ES culture:             561A

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 UShort = 22042
      
      For Each specifier As String In specifiers
         For Each culture As CultureInfo In Cultures
            Console.WriteLine("{0,2} format using {1} culture: {2, 16}", _ 
                              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:            22042
'        G format using fr-FR culture:            22042
'        G format using es-ES culture:            22042
'       
'        C format using en-US culture:       $22,042.00
'        C format using fr-FR culture:      22 042,00 €
'        C format using es-ES culture:      22.042,00 €
'       
'       D4 format using en-US culture:            22042
'       D4 format using fr-FR culture:            22042
'       D4 format using es-ES culture:            22042
'       
'       E2 format using en-US culture:        2.20E+004
'       E2 format using fr-FR culture:        2,20E+004
'       E2 format using es-ES culture:        2,20E+004
'       
'        F format using en-US culture:         22042.00
'        F format using fr-FR culture:         22042,00
'        F format using es-ES culture:         22042,00
'       
'        N format using en-US culture:        22,042.00
'        N format using fr-FR culture:        22 042,00
'        N format using es-ES culture:        22.042,00
'       
'        P format using en-US culture:   2,204,200.00 %
'        P format using fr-FR culture:   2 204 200,00 %
'        P format using es-ES culture:   2.204.200,00 %
'       
'       X2 format using en-US culture:             561A
'       X2 format using fr-FR culture:             561A
'       X2 format using es-ES culture:             561A

Commenti

Il ToString(String, IFormatProvider) metodo formatta un UInt16 valore in un formato specificato utilizzando l'oggetto NumberFormatInfo di impostazioni cultura specificate. Se si desidera usare le impostazioni di formato o impostazioni cultura predefinite, usare gli altri overload del ToString metodo, come indicato di seguito:

Il format parametro può essere qualsiasi stringa di formato numerico standard valida o qualsiasi combinazione di stringhe di formato numerico personalizzato. Se format è uguale a String.Empty o è null, il valore restituito dell'oggetto corrente UInt16 viene formattato con l'identificatore di formato generale ("G"). Se format è un altro valore, il metodo genera un oggetto FormatException.

.NET offre un supporto completo per la formattazione, descritto in modo più dettagliato negli argomenti di formattazione seguenti:

• Per altre informazioni sugli identificatori di formato numerico, vedere Stringhe di formato numerico standard e stringhe di formato numerico personalizzato.

• Per altre informazioni sulla formattazione, vedere Formattazione dei tipi.

Il provider parametro è un'implementazione IFormatProvider . Il metodo GetFormat restituisce un NumberFormatInfo oggetto che fornisce informazioni specifiche delle impostazioni cultura sul formato della stringa restituita da questo metodo. Quando il ToString(String, IFormatProvider) metodo viene richiamato, chiama il provider metodo del IFormatProvider.GetFormat parametro e lo passa a un Type oggetto che rappresenta il NumberFormatInfo tipo. Il GetFormat metodo restituisce quindi l'oggetto NumberFormatInfo che fornisce informazioni per la formattazione del valore corrente UInt16 , ad esempio il simbolo separatore di gruppo o il simbolo di virgola decimale. Esistono tre modi per usare il provider parametro per fornire informazioni di formattazione al ToString(String, IFormatProvider) metodo :

• È possibile passare un CultureInfo oggetto che rappresenta le impostazioni cultura che forniscono informazioni di formattazione. Il metodo GetFormat restituisce l'oggetto NumberFormatInfo che fornisce informazioni sulla formattazione numerica per tali impostazioni cultura.

• È possibile passare l'oggetto effettivo NumberFormatInfo che fornisce informazioni sulla formattazione numerica. L'implementazione di GetFormat just restituisce se stessa.

• È possibile passare un oggetto personalizzato che implementa IFormatProvider. Il GetFormat metodo crea un'istanza e restituisce l'oggetto NumberFormatInfo che fornisce informazioni di formattazione.

Se provider è null, la formattazione della stringa restituita è basata sull'oggetto NumberFormatInfo delle impostazioni cultura correnti.

Vedi anche

• Parse(String)
• Formattazione di tipi in .NET
• Procedura: aggiungere zeri iniziali a un numero
• Esempio: Utilità di formattazione di .NET Core WinForms (C#)
• Esempio: Utilità di formattazione di .NET Core WinForms (Visual Basic)

Origine:

UInt16.cs

Origine:

UInt16.cs

Origine:

UInt16.cs

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

public override string ToString ();

override this.ToString : unit -> string

Public Overrides Function ToString () As String

Restituisce

Rappresentazione di stringa del valore di questa istanza, composto da una sequenza di cifre comprese tra 0 e 9 senza segno o zeri iniziali.

Esempio

Nell'esempio seguente viene visualizzato un UInt16 valore usando il metodo predefinito ToString() . Vengono inoltre visualizzate le rappresentazioni di stringa del UInt16 valore risultante dall'uso di alcuni identificatori di formato standard. Gli esempi vengono visualizzati usando le convenzioni di formattazione delle impostazioni cultura en-US.

using System;

public class Example
{
   public static void Main()
   {
      ushort value = 16324;
      // 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,12}", 
                           format, value.ToString(format));         
   }
}
// The example displays the following output:
//       16324
//
//       G format specifier:        16324
//       C format specifier:   $16,324.00
//       D format specifier:        16324
//       F format specifier:     16324.00
//       N format specifier:    16,324.00
//       X format specifier:         3FC4

let value = 16324us
// 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,12}" 
// The example displays the following output:
//       16324
//
//       G format specifier:        16324
//       C format specifier:   $16,324.00
//       D format specifier:        16324
//       F format specifier:     16324.00
//       N format specifier:    16,324.00
//       X format specifier:         3FC4

Module Example
   Public Sub Main()
      Dim value As UInt16 = 16324
      ' 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,12}", _
                           format, value.ToString(format))         
      Next
   End Sub
End Module
' The example displays the following output:
'       16324
'       
'       G format specifier:        16324
'       C format specifier:   $16,324.00
'       D format specifier:        16324
'       F format specifier:     16324.00
'       N format specifier:    16,324.00
'       X format specifier:         3FC4

Commenti

Il ToString() metodo formatta un UInt16 valore nel formato predefinito ("G" o generale) usando l'oggetto NumberFormatInfo delle impostazioni cultura correnti. Se si desidera specificare un formato o impostazioni cultura diverse, usare gli altri overload del ToString metodo, come indicato di seguito:

Vedi anche

• Parse(String)
• Formattazione di tipi in .NET