Procedura: aggiungere zeri iniziali a un numeroHow to: Pad a Number with Leading Zeros

È possibile aggiungere degli zeri iniziali a un numero intero usando la stringa di formato numerico standard "D" con un identificatore di precisione.You can add leading zeros to an integer by using the "D" standard numeric format string with a precision specifier. È possibile aggiungere zeri iniziali sia ai numeri interi che ai numeri a virgola mobile usando una stringa di formato numerico personalizzata.You can add leading zeros to both integer and floating-point numbers by using a custom numeric format string. In questo argomento viene illustrato come usare entrambi i metodi per aggiungere un numero con gli zeri iniziali.This topic shows how to use both methods to pad a number with leading zeros.

Per aggiungere un intero con gli zeri iniziali a una lunghezza specificaTo pad an integer with leading zeros to a specific length

  1. Determinare il numero minimo di cifre da visualizzare nel valore di tipo Integer.Determine the minimum number of digits you want the integer value to display. Includere eventuali cifre iniziali nel numero.Include any leading digits in this number.

  2. Determinare se si vuole visualizzare il valore di tipo Integer come valore decimale o esadecimale.Determine whether you want to display the integer as a decimal value or a hexadecimal value.

    • Per visualizzare il valore di tipo Integer come valore decimale, chiamare il metodo ToString(String) e passare la stringa "Dn" come valore del parametro format, dove n rappresenta la lunghezza minima della stringa.To display the integer as a decimal value, call its ToString(String) method, and pass the string "Dn" as the value of the format parameter, where n represents the minimum length of the string.

    • Per visualizzare il valore di tipo Integer come valore esadecimale, chiamare il metodo ToString(String) e passare la stringa "Xn" come valore del parametro format, dove n rappresenta la lunghezza minima della stringa.To display the integer as a hexadecimal value, call its ToString(String) method and pass the string "Xn" as the value of the format parameter, where n represents the minimum length of the string.

    È anche possibile usare la stringa di formato in un metodo, come Format o WriteLine, che usa la formattazione composita.You can also use the format string in a method, such as Format or WriteLine, that uses composite formatting.

Il seguente esempio formatta diversi valori di tipo Integer con gli zeri iniziali in modo che la lunghezza totale del numero formattato sia almeno di otto caratteri.The following example formats several integer values with leading zeros so that the total length of the formatted number is at least eight characters.

byte byteValue = 254;
short shortValue = 10342;
int intValue = 1023983;
long lngValue = 6985321;               
ulong ulngValue = UInt64.MaxValue;

// Display integer values by calling the ToString method.
Console.WriteLine("{0,22} {1,22}", byteValue.ToString("D8"), byteValue.ToString("X8"));
Console.WriteLine("{0,22} {1,22}", shortValue.ToString("D8"), shortValue.ToString("X8"));
Console.WriteLine("{0,22} {1,22}", intValue.ToString("D8"), intValue.ToString("X8"));
Console.WriteLine("{0,22} {1,22}", lngValue.ToString("D8"), lngValue.ToString("X8"));
Console.WriteLine("{0,22} {1,22}", ulngValue.ToString("D8"), ulngValue.ToString("X8"));
Console.WriteLine();

// Display the same integer values by using composite formatting.
Console.WriteLine("{0,22:D8} {0,22:X8}", byteValue);
Console.WriteLine("{0,22:D8} {0,22:X8}", shortValue);
Console.WriteLine("{0,22:D8} {0,22:X8}", intValue);
Console.WriteLine("{0,22:D8} {0,22:X8}", lngValue);
Console.WriteLine("{0,22:D8} {0,22:X8}", ulngValue);
// The example displays the following output:
//                     00000254               000000FE
//                     00010342               00002866
//                     01023983               000F9FEF
//                     06985321               006A9669
//         18446744073709551615       FFFFFFFFFFFFFFFF
//       
//                     00000254               000000FE
//                     00010342               00002866
//                     01023983               000F9FEF
//                     06985321               006A9669
//         18446744073709551615       FFFFFFFFFFFFFFFF
//         18446744073709551615       FFFFFFFFFFFFFFFF
Dim byteValue As Byte = 254
Dim shortValue As Short = 10342
Dim intValue As Integer = 1023983
Dim lngValue As Long = 6985321               
Dim ulngValue As ULong = UInt64.MaxValue

' Display integer values by calling the ToString method.
Console.WriteLine("{0,22} {1,22}", byteValue.ToString("D8"), byteValue.ToString("X8"))
Console.WriteLine("{0,22} {1,22}", shortValue.ToString("D8"), shortValue.ToString("X8"))
Console.WriteLine("{0,22} {1,22}", intValue.ToString("D8"), intValue.ToString("X8"))
Console.WriteLine("{0,22} {1,22}", lngValue.ToString("D8"), lngValue.ToString("X8"))
Console.WriteLine("{0,22} {1,22}", ulngValue.ToString("D8"), ulngValue.ToString("X8"))
Console.WriteLine()

' Display the same integer values by using composite formatting.
Console.WriteLine("{0,22:D8} {0,22:X8}", byteValue)
Console.WriteLine("{0,22:D8} {0,22:X8}", shortValue)
Console.WriteLine("{0,22:D8} {0,22:X8}", intValue)
Console.WriteLine("{0,22:D8} {0,22:X8}", lngValue)
Console.WriteLine("{0,22:D8} {0,22:X8}", ulngValue)
' The example displays the following output:
'                     00000254               000000FE
'                     00010342               00002866
'                     01023983               000F9FEF
'                     06985321               006A9669
'         18446744073709551615       FFFFFFFFFFFFFFFF
'       
'                     00000254               000000FE
'                     00010342               00002866
'                     01023983               000F9FEF
'                     06985321               006A9669
'         18446744073709551615       FFFFFFFFFFFFFFFF

Per aggiungere un intero con un determinato numero di zeri inizialiTo pad an integer with a specific number of leading zeros

  1. Determinare il numero di zeri iniziali da visualizzare nel valore di tipo Integer.Determine how many leading zeros you want the integer value to display.

  2. Determinare se si vuole visualizzare il valore di tipo Integer come valore decimale o esadecimale.Determine whether you want to display the integer as a decimal value or a hexadecimal value. Se si formatta come valore decimale, è necessario usare l'identificatore di formato standard "D", mentre come valore esadecimale è necessario usare l'identificatore di formato "X".Formatting it as a decimal value requires that you use the "D" standard format specifier; formatting it as a hexadecimal value requires that you use the "X" standard format specifier.

  3. Determinare la lunghezza della stringa numerica non aggiunta chiamando il metodo ToString("D").Length o ToString("X").Length del valore di tipo Integer.Determine the length of the unpadded numeric string by calling the integer value's ToString("D").Length or ToString("X").Length method.

  4. Aggiungere il numero di zeri iniziali da includere nella stringa formattata nella lunghezza della stringa numerica non aggiunta.Add the number of leading zeros that you want to include in the formatted string to the length of the unpadded numeric string. In questo modo si definisce la lunghezza totale della stringa aggiunta.This defines the total length of the padded string.

  5. Chiamare il metodo ToString(String) del valore integer e passare la stringa "Dn" per le stringhe decimali e la stringa "Xn" per quelle esadecimali, dove n rappresenta la lunghezza totale della stringa aggiunta.Call the integer value's ToString(String) method, and pass the string "Dn" for decimal strings and "Xn" for hexadecimal strings, where n represents the total length of the padded string. È anche possibile usare la stringa di formato "Dn" o "Xn" in un metodo che supporta la formattazione composta.You can also use the "Dn" or "Xn" format string in a method that supports composite formatting.

Il seguente esempio aggiunge un valore di tipo Integer con cinque zeri iniziali.The following example pads an integer value with five leading zeros.

int value = 160934;
int decimalLength = value.ToString("D").Length + 5;
int hexLength = value.ToString("X").Length + 5;
Console.WriteLine(value.ToString("D" + decimalLength.ToString()));
Console.WriteLine(value.ToString("X" + hexLength.ToString()));
// The example displays the following output:
//       00000160934
//       00000274A6      
Dim value As Integer = 160934
Dim decimalLength As Integer = value.ToString("D").Length + 5
Dim hexLength As Integer = value.ToString("X").Length + 5
Console.WriteLine(value.ToString("D" + decimalLength.ToString()))
Console.WriteLine(value.ToString("X" + hexLength.ToString()))
' The example displays the following output:
'       00000160934
'       00000274A6      

Per aggiungere un valore numerico con gli zeri iniziali a una lunghezza specificaTo pad a numeric value with leading zeros to a specific length

  1. Determinare il numero di cifre alla sinistra del decimale che deve avere la rappresentazione della stringa del numero.Determine how many digits to the left of the decimal you want the string representation of the number to have. Includere gli eventuali zeri iniziali nel numero totale di cifre.Include any leading zeros in this total number of digits.

  2. Definire una stringa di formato numerico personalizzata in cui è usato un segnaposto zero ("0") per rappresentare il numero minimo di zeri.Define a custom numeric format string that uses the zero placeholder ("0") to represent the minimum number of zeros.

  3. Chiamare il metodo ToString(String) del numero e passarlo alla stringa di formato personalizzata.Call the number's ToString(String) method and pass it the custom format string. È anche possibile usare la stringa di formato personalizzata con un metodo che supporta la formattazione composta.You can also use the custom format string with a method that supports composite formatting.

Il seguente esempio formatta diversi valori numerici con gli zeri iniziali in modo che la lunghezza totale del numero formattato sia almeno di otto caratteri alla sinistra del decimale.The following example formats several numeric values with leading zeros so that the total length of the formatted number is at least eight digits to the left of the decimal.

string fmt = "00000000.##";
int intValue = 1053240;
decimal decValue = 103932.52m;
float sngValue = 1549230.10873992f;
double dblValue = 9034521202.93217412;

// Display the numbers using the ToString method.
Console.WriteLine(intValue.ToString(fmt));
Console.WriteLine(decValue.ToString(fmt));           
Console.WriteLine(sngValue.ToString(fmt));
Console.WriteLine(dblValue.ToString(fmt));           
Console.WriteLine();

// Display the numbers using composite formatting.
string formatString = " {0,15:" + fmt + "}";
Console.WriteLine(formatString, intValue);      
Console.WriteLine(formatString, decValue);      
Console.WriteLine(formatString, sngValue);      
Console.WriteLine(formatString, dblValue);      
// The example displays the following output:
//       01053240
//       00103932.52
//       01549230
//       9034521202.93
//       
//               01053240
//            00103932.52
//               01549230
//          9034521202.93      
Dim fmt As String = "00000000.##"
Dim intValue As Integer = 1053240
Dim decValue As Decimal = 103932.52d
Dim sngValue As Single = 1549230.10873992
Dim dblValue As Double = 9034521202.93217412

' Display the numbers using the ToString method.
Console.WriteLine(intValue.ToString(fmt))
Console.WriteLine(decValue.ToString(fmt))            
Console.WriteLine(sngValue.ToString(fmt))
Console.WriteLine(dblValue.ToString(fmt))            
Console.WriteLine()

' Display the numbers using composite formatting.
Dim formatString As String = " {0,15:" + fmt + "}"
Console.WriteLine(formatString, intValue)      
Console.WriteLine(formatString, decValue)      
Console.WriteLine(formatString, sngValue)      
Console.WriteLine(formatString, dblValue)      
' The example displays the following output:
'       01053240
'       00103932.52
'       01549230
'       9034521202.93
'       
'               01053240
'            00103932.52
'               01549230
'          9034521202.93      

Per aggiungere un valore numerico con un determinato numero di zeri inizialiTo pad a numeric value with a specific number of leading zeros

  1. Determinare il numero di zeri iniziali che deve avere il valore numerico.Determine how many leading zeros you want the numeric value to have.

  2. Determinare il numero di cifre alla sinistra del decimale nella stringa numerica non aggiunta.Determine the number of digits to the left of the decimal in the unpadded numeric string. Per eseguire questa operazione:To do this:

    1. Determinare se la rappresentazione della stringa di un numero include un simbolo di separatore decimale.Determine whether the string representation of a number includes a decimal point symbol.

    2. In questo caso, determinare il numero di caratteri alla sinistra del separatore decimale.If it does include a decimal point symbol, determine the number of characters to the left of the decimal point.

      oppure-or-

      In caso contrario, determinare la lunghezza della stringa.If it does not include a decimal point symbol, determine the string's length.

  3. Creare una stringa di formato personalizzata in cui è usato il segnaposto zero ("0") per ciascuno degli zeri iniziali da visualizzare nella stringa e il segnaposto zero o il segnaposto cifra ("#") per rappresentare ciascuna cifra nella stringa predefinita.Create a custom format string that uses the zero placeholder ("0") for each of the leading zeros to appear in the string, and that uses either the zero placeholder or the digit placeholder ("#") to represent each digit in the default string.

  4. Fornire la stringa di formato personalizzata come parametro nel metodo ToString(String) del numero o in un metodo che supporta la formattazione composta.Supply the custom format string as a parameter either to the number's ToString(String) method or to a method that supports composite formatting.

Il seguente esempio aggiunge due valori Double con cinque zeri iniziali.The following example pads two Double values with five leading zeros.

double[] dblValues = { 9034521202.93217412, 9034521202 };
foreach (double dblValue in dblValues)
{
   string decSeparator = System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator;
   string fmt, formatString;
   
   if (dblValue.ToString().Contains(decSeparator))
   {
      int digits = dblValue.ToString().IndexOf(decSeparator);
      fmt = new String('0', 5) + new String('#', digits) + ".##";
   }
   else
   {
      fmt = new String('0', dblValue.ToString().Length);   
   }
   formatString = "{0,20:" + fmt + "}";

   Console.WriteLine(dblValue.ToString(fmt));
   Console.WriteLine(formatString, dblValue);
}
// The example displays the following output:
//       000009034521202.93
//         000009034521202.93
//       9034521202
//                 9034521202            
Dim dblValues() As Double = { 9034521202.93217412, 9034521202 }
For Each dblValue As Double In dblValues
   Dim decSeparator As String = System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator
   Dim fmt, formatString As String
   
   If dblValue.ToString.Contains(decSeparator) Then
      Dim digits As Integer = dblValue.ToString().IndexOf(decSeparator)
      fmt = New String("0"c, 5) + New String("#"c, digits) + ".##"
   Else
      fmt = New String("0"c, dblValue.ToString.Length)   
   End If
   formatString = "{0,20:" + fmt + "}"

   Console.WriteLine(dblValue.ToString(fmt))
   Console.WriteLine(formatString, dblValue)
Next
' The example displays the following output:
'       000009034521202.93
'         000009034521202.93
'       9034521202
'                 9034521202            

Vedere ancheSee Also

Custom Numeric Format StringsCustom Numeric Format Strings
Standard Numeric Format StringsStandard Numeric Format Strings
Formattazione compositaComposite Formatting