Cadenas de formato TimeSpan personalizadoCustom TimeSpan Format Strings

Una cadena de formato TimeSpan define la representación de cadena de un valor TimeSpan generado por una operación de formato.A TimeSpan format string defines the string representation of a TimeSpan value that results from a formatting operation. Una cadena de formato personalizado consta de uno o varios especificadores de formato TimeSpan personalizado, además de un número de caracteres literales.A custom format string consists of one or more custom TimeSpan format specifiers along with any number of literal characters. Cualquier cadena que no sea una cadena de formato TimeSpan estándar se interpreta como una cadena de formato TimeSpan personalizada.Any string that is not a standard TimeSpan format string is interpreted as a custom TimeSpan format string.

Importante

Los especificadores de formato TimeSpan personalizado no incluyen símbolos de separador de marcadores de posición, como los símbolos que separan los días de las horas, las horas de los minutos o los segundos de las fracciones de segundo.The custom TimeSpan format specifiers do not include placeholder separator symbols, such as the symbols that separate days from hours, hours from minutes, or seconds from fractional seconds. Estos símbolos deben incluirse en la cadena de formato personalizado como literales de cadena.Instead, these symbols must be included in the custom format string as string literals. Por ejemplo, "dd\.hh\:mm" define un punto (.) como separador entre los días y las horas, y un signo de dos puntos (:) como separador entre las horas y los minutos.For example, "dd\.hh\:mm" defines a period (.) as the separator between days and hours, and a colon (:) as the separator between hours and minutes.

Los especificadores de formato TimeSpan personalizado tampoco incluyen un símbolo de signo que permita distinguir entre los intervalos de tiempo negativos y positivos.Custom TimeSpan format specifiers also do not include a sign symbol that enables you to differentiate between negative and positive time intervals. Para incluir un símbolo de signo, es necesario construir una cadena de formato utilizando lógica condicional.To include a sign symbol, you have to construct a format string by using conditional logic. En la sección Otros caracteres se incluye un ejemplo.The Other Characters section includes an example.

Las representaciones de cadena de los valores TimeSpan se generan mediante llamadas a las sobrecargas del método TimeSpan.ToString, y también mediante métodos que admiten formatos compuestos, como String.Format.The string representations of TimeSpan values are produced by calls to the overloads of the TimeSpan.ToString method, and by methods that support composite formatting, such as String.Format. Para obtener más información, consulte Aplicar formato a tipos y Formatos compuestos.For more information, see Formatting Types and Composite Formatting. En el siguiente ejemplo, se muestra el uso de cadenas de formato personalizado en operaciones de formato.The following example illustrates the use of custom format strings in formatting operations.

using System;

public class Example
{
   public static void Main()
   {
      TimeSpan duration = new TimeSpan(1, 12, 23, 62);

      string output = null;
      output = "Time of Travel: " + duration.ToString("%d") + " days";
      Console.WriteLine(output);
      output = "Time of Travel: " + duration.ToString(@"dd\.hh\:mm\:ss"); 
      Console.WriteLine(output);

      Console.WriteLine("Time of Travel: {0:%d} day(s)", duration);
      Console.WriteLine("Time of Travel: {0:dd\\.hh\\:mm\\:ss} days", duration);
   }
}
// The example displays the following output:
//       Time of Travel: 1 days
//       Time of Travel: 01.12:24:02
//       Time of Travel: 1 day(s)
//       Time of Travel: 01.12:24:02 days
Module Example
   Public Sub Main()
      Dim duration As New TimeSpan(1, 12, 23, 62)

      Dim output As String = Nothing
      output = "Time of Travel: " + duration.ToString("%d") + " days"
      Console.WriteLine(output)
      output = "Time of Travel: " + duration.ToString("dd\.hh\:mm\:ss") 
      Console.WriteLine(output)

      Console.WriteLine("Time of Travel: {0:%d} day(s)", duration)
      Console.WriteLine("Time of Travel: {0:dd\.hh\:mm\:ss} days", duration)
   End Sub
End Module
' The example displays the following output:
'       Time of Travel: 1 days
'       Time of Travel: 01.12:24:02
'       Time of Travel: 1 day(s)
'       Time of Travel: 01.12:24:02 days

Los métodos TimeSpan y TimeSpan.ParseExact también usan cadenas de formato TimeSpan.TryParseExact personalizadas para definir el formato que deben tener las cadenas de entrada de las operaciones de análisis.Custom TimeSpan format strings are also used by the TimeSpan.ParseExact and TimeSpan.TryParseExact methods to define the required format of input strings for parsing operations. (Estas operaciones convierten la representación de cadena de un valor en ese valor.) En el siguiente ejemplo, se muestra el uso de cadenas de formato estándar en operaciones de análisis.(Parsing converts the string representation of a value to that value.) The following example illustrates the use of standard format strings in parsing operations.

using System;

public class Example
{
   public static void Main()
   {
      string value = null;
      TimeSpan interval;

      value = "6";
      if (TimeSpan.TryParseExact(value, "%d", null, out interval))
         Console.WriteLine("{0} --> {1}", value, interval.ToString("c"));
      else
         Console.WriteLine("Unable to parse '{0}'", value);
      
      value = "16:32.05";
      if (TimeSpan.TryParseExact(value, @"mm\:ss\.ff", null, out interval))
         Console.WriteLine("{0} --> {1}", value, interval.ToString("c"));
      else
         Console.WriteLine("Unable to parse '{0}'", value);

      value= "12.035";
      if (TimeSpan.TryParseExact(value, "ss\\.fff", null, out interval))
         Console.WriteLine("{0} --> {1}", value, interval.ToString("c"));
      else
         Console.WriteLine("Unable to parse '{0}'", value);
   }
}
// The example displays the following output:
//       6 --> 6.00:00:00
//       16:32.05 --> 00:16:32.0500000
//       12.035 --> 00:00:12.0350000
Module Example
   Public Sub Main()
      Dim value As String = Nothing
      Dim interval As TimeSpan

      value = "6"
      If TimeSpan.TryParseExact(value, "%d", Nothing, interval) Then
         Console.WriteLine("{0} --> {1}", value, interval.ToString("c"))
      Else
         Console.WriteLine("Unable to parse '{0}'", value)
      End If
      
      value = "16:32.05"
      If TimeSpan.TryParseExact(value, "mm\:ss\.ff", Nothing, interval) Then
         Console.WriteLine("{0} --> {1}", value, interval.ToString("c"))
      Else
         Console.WriteLine("Unable to parse '{0}'", value)
      End If

      value= "12.035"
      If TimeSpan.TryParseExact(value, "ss\.fff", Nothing, interval) Then
         Console.WriteLine("{0} --> {1}", value, interval.ToString("c"))
      Else
         Console.WriteLine("Unable to parse '{0}'", value)
      End If
   End Sub
End Module
' The example displays the following output:
'       6 --> 6.00:00:00
'       16:32.05 --> 00:16:32.0500000
'       12.035 --> 00:00:12.0350000

En la siguiente tabla se describen los especificadores de formato de fecha y hora personalizado.The following table describes the custom date and time format specifiers.

Especificador de formatoFormat specifier DescriptionDescription EjemploExample
"d", "%d""d", "%d" Número de días completos de un intervalo de tiempo.The number of whole days in the time interval.

Más información: El especificador de formato personalizado "d".More information: The "d" Custom Format Specifier.
new TimeSpan(6, 14, 32, 17, 685):

%d --> "6"%d --> "6"

d\.hh\:mm --> "6.14:32"d\.hh\:mm --> "6.14:32"
"dd"-"dddddddd""dd"-"dddddddd" Número de días completos de un intervalo de tiempo, que se completa con tantos ceros iniciales como sean necesarios.The number of whole days in the time interval, padded with leading zeros as needed.

Más información: Especificadores de formato personalizado "dd"-"dddddddd".More information: The "dd"-"dddddddd" Custom Format Specifiers.
new TimeSpan(6, 14, 32, 17, 685):

ddd --> "006"ddd --> "006"

dd\.hh\:mm --> "06.14:32"dd\.hh\:mm --> "06.14:32"
"h", "%h""h", "%h" Número de horas completas de un intervalo de tiempo que no se cuentan como parte de los días.The number of whole hours in the time interval that are not counted as part of days. Las horas con un solo dígito no se escriben con un cero a la izquierda.Single-digit hours do not have a leading zero.

Más información: El especificador de formato personalizado "h".More information: The "h" Custom Format Specifier.
new TimeSpan(6, 14, 32, 17, 685):

%h --> "14"%h --> "14"

hh\:mm --> "14:32"hh\:mm --> "14:32"
"hh""hh" Número de horas completas de un intervalo de tiempo que no se cuentan como parte de los días.The number of whole hours in the time interval that are not counted as part of days. Las horas con un solo dígito se escriben con un cero a la izquierda.Single-digit hours have a leading zero.

Más información: El especificador de formato personalizado "hh".More information: The "hh" Custom Format Specifier.
new TimeSpan(6, 14, 32, 17, 685):

hh --> "14"hh --> "14"

new TimeSpan(6, 8, 32, 17, 685):

hh --> 08hh --> 08
"m", "%m""m", "%m" Número de minutos completos de un intervalo de tiempo que no se incluyen como parte de las horas o los días.The number of whole minutes in the time interval that are not included as part of hours or days. Los minutos con un solo dígito no se escriben con un cero a la izquierda.Single-digit minutes do not have a leading zero.

Más información: El especificador de formato personalizado "m".More information: The "m" Custom Format Specifier.
new TimeSpan(6, 14, 8, 17, 685):

%m --> "8"%m --> "8"

h\:m --> "14:8"h\:m --> "14:8"
"mm""mm" Número de minutos completos de un intervalo de tiempo que no se incluyen como parte de las horas o los días.The number of whole minutes in the time interval that are not included as part of hours or days. Los minutos con un solo dígito se escriben con un cero a la izquierda.Single-digit minutes have a leading zero.

Más información: El especificador de formato personalizado "mm".More information: The "mm" Custom Format Specifier.
new TimeSpan(6, 14, 8, 17, 685):

mm --> "08"mm --> "08"

new TimeSpan(6, 8, 5, 17, 685):

d\.hh\:mm\:ss --> 6.08:05:17d\.hh\:mm\:ss --> 6.08:05:17
"s", "%s""s", "%s" Número de segundos completos de un intervalo de tiempo que no se incluyen como parte de las horas, los días o los minutos.The number of whole seconds in the time interval that are not included as part of hours, days, or minutes. Los segundos con un solo dígito no se escriben con un cero a la izquierda.Single-digit seconds do not have a leading zero.

Más información: El especificador de formato personalizado "s".More information: The "s" Custom Format Specifier.
TimeSpan.FromSeconds(12.965):TimeSpan.FromSeconds(12.965):

%s --> 12%s --> 12

s\.fff --> 12.965s\.fff --> 12.965
"ss""ss" Número de segundos completos de un intervalo de tiempo que no se incluyen como parte de las horas, los días o los minutos.The number of whole seconds in the time interval that are not included as part of hours, days, or minutes. Los segundos con un solo dígito se escriben con un cero a la izquierda.Single-digit seconds have a leading zero.

Más información: El especificador de formato personalizado "ss".More information: The "ss" Custom Format Specifier.
TimeSpan.FromSeconds(6.965):TimeSpan.FromSeconds(6.965):

ss --> 06ss --> 06

ss\.fff --> 06.965ss\.fff --> 06.965
"f", "%f""f", "%f" Décimas de segundo de un intervalo de tiempo.The tenths of a second in a time interval.

Más información: El especificador de formato personalizado "f".More information: The "f" Custom Format Specifier.
TimeSpan.FromSeconds(6.895):TimeSpan.FromSeconds(6.895):

f --> 8f --> 8

ss\.f --> 06.8ss\.f --> 06.8
"ff""ff" Centésimas de segundo de un intervalo de tiempo.The hundredths of a second in a time interval.

Más información: El especificador de formato personalizado "ff".More information:The "ff" Custom Format Specifier.
TimeSpan.FromSeconds(6.895):TimeSpan.FromSeconds(6.895):

ff --> 89ff --> 89

ss\.ff --> 06.89ss\.ff --> 06.89
"fff""fff" Milisegundos de un intervalo de tiempo.The milliseconds in a time interval.

Más información: El especificador de formato personalizado "fff".More information: The "fff" Custom Format Specifier.
TimeSpan.FromSeconds(6.895):TimeSpan.FromSeconds(6.895):

fff --> 895fff --> 895

ss\.fff --> 06.895ss\.fff --> 06.895
"ffff""ffff" Diezmilésimas de segundo de un intervalo de tiempo.The ten-thousandths of a second in a time interval.

Más información: El especificador de formato personalizado "ffff".More information: The "ffff" Custom Format Specifier.
TimeSpan.Parse("0:0:6.8954321"):TimeSpan.Parse("0:0:6.8954321"):

ffff --> 8954ffff --> 8954

ss\.ffff --> 06.8954ss\.ffff --> 06.8954
"fffff""fffff" Cienmilésimas de segundo de un intervalo de tiempo.The hundred-thousandths of a second in a time interval.

Más información: El especificador de formato personalizado "fffff".More information: The "fffff" Custom Format Specifier.
TimeSpan.Parse("0:0:6.8954321"):TimeSpan.Parse("0:0:6.8954321"):

fffff --> 89543fffff --> 89543

ss\.fffff --> 06.89543ss\.fffff --> 06.89543
"ffffff""ffffff" Millonésimas de segundo de un intervalo de tiempo.The millionths of a second in a time interval.

Más información: El especificador de formato personalizado "ffffff".More information: The "ffffff" Custom Format Specifier.
TimeSpan.Parse("0:0:6.8954321"):TimeSpan.Parse("0:0:6.8954321"):

ffffff --> 895432ffffff --> 895432

ss\.ffffff --> 06.895432ss\.ffffff --> 06.895432
"fffffff""fffffff" Diezmillonésimas de segundo (o fracciones de paso) de un intervalo de tiempo.The ten-millionths of a second (or the fractional ticks) in a time interval.

Más información: El especificador de formato personalizado "fffffff".More information: The "fffffff" Custom Format Specifier.
TimeSpan.Parse("0:0:6.8954321"):TimeSpan.Parse("0:0:6.8954321"):

fffffff --> 8954321fffffff --> 8954321

ss\.fffffff --> 06.8954321ss\.fffffff --> 06.8954321
"F", "%F""F", "%F" Décimas de segundo de un intervalo de tiempo.The tenths of a second in a time interval. Si el dígito es cero, no se muestra nada.Nothing is displayed if the digit is zero.

Más información: El especificador de formato personalizado "F".More information: The "F" Custom Format Specifier.
TimeSpan.Parse("00:00:06.32"):TimeSpan.Parse("00:00:06.32"):

%F: 3%F: 3

TimeSpan.Parse("0:0:3.091"):TimeSpan.Parse("0:0:3.091"):

ss\.F: 03.ss\.F: 03.
"FF""FF" Centésimas de segundo de un intervalo de tiempo.The hundredths of a second in a time interval. No se incluyen los ceros finales fraccionarios ni los dígitos de dos ceros.Any fractional trailing zeros or two zero digits are not included.

Más información: El especificador de formato personalizado "FF".More information: The "FF" Custom Format Specifier.
TimeSpan.Parse("00:00:06.329"):TimeSpan.Parse("00:00:06.329"):

FF: 32FF: 32

TimeSpan.Parse("0:0:3.101"):TimeSpan.Parse("0:0:3.101"):

ss\.FF: 03.1ss\.FF: 03.1
"FFF""FFF" Milisegundos de un intervalo de tiempo.The milliseconds in a time interval. No se incluyen los ceros finales fraccionarios.Any fractional trailing zeros are not included.

Más información:More information:
TimeSpan.Parse("00:00:06.3291"):TimeSpan.Parse("00:00:06.3291"):

FFF: 329FFF: 329

TimeSpan.Parse("0:0:3.1009"):TimeSpan.Parse("0:0:3.1009"):

ss\.FFF: 03.1ss\.FFF: 03.1
"FFFF""FFFF" Diezmilésimas de segundo de un intervalo de tiempo.The ten-thousandths of a second in a time interval. No se incluyen los ceros finales fraccionarios.Any fractional trailing zeros are not included.

Más información: El especificador de formato personalizado "FFFF".More information: The "FFFF" Custom Format Specifier.
TimeSpan.Parse("00:00:06.32917"):TimeSpan.Parse("00:00:06.32917"):

FFFFF: 3291FFFFF: 3291

TimeSpan.Parse("0:0:3.10009"):TimeSpan.Parse("0:0:3.10009"):

ss\.FFFF: 03.1ss\.FFFF: 03.1
"FFFFF""FFFFF" Cienmilésimas de segundo de un intervalo de tiempo.The hundred-thousandths of a second in a time interval. No se incluyen los ceros finales fraccionarios.Any fractional trailing zeros are not included.

Más información: El especificador de formato personalizado "FFFFF".More information: The "FFFFF" Custom Format Specifier.
TimeSpan.Parse("00:00:06.329179"):TimeSpan.Parse("00:00:06.329179"):

FFFFF: 32917FFFFF: 32917

TimeSpan.Parse("0:0:3.100009"):TimeSpan.Parse("0:0:3.100009"):

ss\.FFFFF: 03.1ss\.FFFFF: 03.1
"FFFFFF""FFFFFF" Millonésimas de segundo de un intervalo de tiempo.The millionths of a second in a time interval. No se muestran los ceros finales fraccionarios.Any fractional trailing zeros are not displayed.

Más información: El especificador de formato personalizado "FFFFFF".More information: The "FFFFFF" Custom Format Specifier.
TimeSpan.Parse("00:00:06.3291791"):TimeSpan.Parse("00:00:06.3291791"):

FFFFFF: 329179FFFFFF: 329179

TimeSpan.Parse("0:0:3.1000009"):TimeSpan.Parse("0:0:3.1000009"):

ss\.FFFFFF: 03.1ss\.FFFFFF: 03.1
"FFFFFFF""FFFFFFF" Diezmillonésimas de segundo de un intervalo de tiempo.The ten-millions of a second in a time interval. No se muestran los ceros finales fraccionarios ni los dígitos de siete ceros.Any fractional trailing zeros or seven zeros are not displayed.

Más información: El especificador de formato personalizado "FFFFFFF".More information: The "FFFFFFF" Custom Format Specifier.
TimeSpan.Parse("00:00:06.3291791"):TimeSpan.Parse("00:00:06.3291791"):

FFFFFF: 3291791FFFFFF: 3291791

TimeSpan.Parse("0:0:3.1900000"):TimeSpan.Parse("0:0:3.1900000"):

ss\.FFFFFF: 03.19ss\.FFFFFF: 03.19
'string''string' Delimitador de cadena literal.Literal string delimiter.

Más información: Otros caracteres.More information: Other Characters.
new TimeSpan(14, 32, 17):

hh':'mm':'ss --> "14:32:17"hh':'mm':'ss --> "14:32:17"
\|El carácter de escape.\|The escape character.

Más información: Otros caracteres.More information:Other Characters.
new TimeSpan(14, 32, 17):

hh\:mm\:ss --> "14:32:17"hh\:mm\:ss --> "14:32:17"
Cualquier otro carácterAny other character Cualquier otro carácter sin escape se interpreta como especificador de formato personalizado.Any other unescaped character is interpreted as a custom format specifier.

Más información: Otros caracteres.More Information: Other Characters.
new TimeSpan(14, 32, 17):

hh\:mm\:ss --> "14:32:17"hh\:mm\:ss --> "14:32:17"

Especificador de formato personalizado "d"The "d" Custom Format Specifier

El especificador de formato personalizado "d" presenta el valor de la propiedad TimeSpan.Days, que representa el número de días completos de un intervalo de tiempo.The "d" custom format specifier outputs the value of the TimeSpan.Days property, which represents the number of whole days in the time interval. Presenta el número completo de días de un valor TimeSpan, incluso si el valor tiene más de un dígito.It outputs the full number of days in a TimeSpan value, even if the value has more than one digit. Si el valor de la propiedad TimeSpan.Days es cero, el especificador presentará "0".If the value of the TimeSpan.Days property is zero, the specifier outputs "0".

Si el especificador de formato personalizado "d" se utiliza solo, especifique "%d" de modo que no se interprete erróneamente como una cadena de formato estándar.If the "d" custom format specifier is used alone, specify "%d" so that it is not misinterpreted as a standard format string. Esto se muestra en el ejemplo siguiente.The following example provides an illustration.

TimeSpan ts1 = new TimeSpan(16, 4, 3, 17, 250);
Console.WriteLine(ts1.ToString("%d"));
// Displays 16   
Dim ts As New TimeSpan(16, 4, 3, 17, 250)
Console.WriteLine(ts.ToString("%d"))
' Displays 16   

En el siguiente ejemplo, se muestra el uso del especificador de formato personalizado "d".The following example illustrates the use of the "d" custom format specifier.

TimeSpan ts2 = new TimeSpan(4, 3, 17);
Console.WriteLine(ts2.ToString(@"d\.hh\:mm\:ss"));

TimeSpan ts3 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine(ts3.ToString(@"d\.hh\:mm\:ss"));
// The example displays the following output:
//       0.04:03:17
//       3.04:03:17      
Dim ts2 As New TimeSpan(4, 3, 17)
Console.WriteLine(ts2.ToString("d\.hh\:mm\:ss"))

Dim ts3 As New TimeSpan(3, 4, 3, 17)
Console.WriteLine(ts3.ToString("d\.hh\:mm\:ss"))
' The example displays the following output:
'       0.04:03:17
'       3.04:03:17      

Volver a la tablaBack to table

Especificadores de formato personalizado "dd"-"dddddddd"The "dd"-"dddddddd" Custom Format Specifiers

Los especificadores de formato personalizado "dd", "ddd", "dddd", "ddddd", "dddddd", "ddddddd" y "dddddddd" presentan el valor de la propiedad TimeSpan.Days, que representa el número de días completos de un intervalo de tiempo.The "dd", "ddd", "dddd", "ddddd", "dddddd", "ddddddd", and "dddddddd" custom format specifiers output the value of the TimeSpan.Days property, which represents the number of whole days in the time interval.

La cadena de salida incluye un número mínimo de dígitos que viene determinado por el número de caracteres "d" en el especificador de formato y se completa con tantos ceros iniciales como sean necesarios.The output string includes a minimum number of digits specified by the number of "d" characters in the format specifier, and it is padded with leading zeros as needed. Si los dígitos del número de días superan el número de caracteres "d" en el especificador de formato, la cadena de resultado mostrará el número completo de días.If the digits in the number of days exceed the number of "d" characters in the format specifier, the full number of days is output in the result string.

En el siguiente ejemplo, se utilizan estos especificadores de formato para mostrar la representación de cadena de dos valores TimeSpan.The following example uses these format specifiers to display the string representation of two TimeSpan values. El valor del componente de días en el primer intervalo de tiempo es cero; el valor del componente de días en el segundo es 365.The value of the days component of the first time interval is zero; the value of the days component of the second is 365.

TimeSpan ts1 = new TimeSpan(0, 23, 17, 47);
TimeSpan ts2 = new TimeSpan(365, 21, 19, 45);

for (int ctr = 2; ctr <= 8; ctr++)
{
   string fmt = new String('d', ctr) + @"\.hh\:mm\:ss";
   Console.WriteLine("{0} --> {1:" + fmt + "}", fmt, ts1);  
   Console.WriteLine("{0} --> {1:" + fmt + "}", fmt, ts2);
   Console.WriteLine();
}  
// The example displays the following output:
//       dd\.hh\:mm\:ss --> 00.23:17:47
//       dd\.hh\:mm\:ss --> 365.21:19:45
//       
//       ddd\.hh\:mm\:ss --> 000.23:17:47
//       ddd\.hh\:mm\:ss --> 365.21:19:45
//       
//       dddd\.hh\:mm\:ss --> 0000.23:17:47
//       dddd\.hh\:mm\:ss --> 0365.21:19:45
//       
//       ddddd\.hh\:mm\:ss --> 00000.23:17:47
//       ddddd\.hh\:mm\:ss --> 00365.21:19:45
//       
//       dddddd\.hh\:mm\:ss --> 000000.23:17:47
//       dddddd\.hh\:mm\:ss --> 000365.21:19:45
//       
//       ddddddd\.hh\:mm\:ss --> 0000000.23:17:47
//       ddddddd\.hh\:mm\:ss --> 0000365.21:19:45
//       
//       dddddddd\.hh\:mm\:ss --> 00000000.23:17:47
//       dddddddd\.hh\:mm\:ss --> 00000365.21:19:45      
Dim ts1 As New TimeSpan(0, 23, 17, 47)
Dim ts2 As New TimeSpan(365, 21, 19, 45)

For ctr As Integer = 2 To 8
   Dim fmt As String = New String("d"c, ctr) + "\.hh\:mm\:ss"
   Console.WriteLine("{0} --> {1:" + fmt + "}", fmt, ts1) 
   Console.WriteLine("{0} --> {1:" + fmt + "}", fmt, ts2)
   Console.WriteLine()
Next  
' The example displays the following output:
'       dd\.hh\:mm\:ss --> 00.23:17:47
'       dd\.hh\:mm\:ss --> 365.21:19:45
'       
'       ddd\.hh\:mm\:ss --> 000.23:17:47
'       ddd\.hh\:mm\:ss --> 365.21:19:45
'       
'       dddd\.hh\:mm\:ss --> 0000.23:17:47
'       dddd\.hh\:mm\:ss --> 0365.21:19:45
'       
'       ddddd\.hh\:mm\:ss --> 00000.23:17:47
'       ddddd\.hh\:mm\:ss --> 00365.21:19:45
'       
'       dddddd\.hh\:mm\:ss --> 000000.23:17:47
'       dddddd\.hh\:mm\:ss --> 000365.21:19:45
'       
'       ddddddd\.hh\:mm\:ss --> 0000000.23:17:47
'       ddddddd\.hh\:mm\:ss --> 0000365.21:19:45
'       
'       dddddddd\.hh\:mm\:ss --> 00000000.23:17:47
'       dddddddd\.hh\:mm\:ss --> 00000365.21:19:45      

Volver a la tablaBack to table

Especificador de formato personalizado "h"The "h" Custom Format Specifier

El especificador de formato personalizado "h" presenta el valor de la propiedad TimeSpan.Hours, que representa el número de horas completas de un intervalo de tiempo que no se cuentan como parte del componente de días.The "h" custom format specifier outputs the value of the TimeSpan.Hours property, which represents the number of whole hours in the time interval that is not counted as part of its day component. Devuelve un valor de cadena de un dígito si el valor de la propiedad TimeSpan.Hours es de 0 a 9; devuelve un valor de cadena de dos dígitos si el valor de la propiedad TimeSpan.Hours es de 10 a 23.It returns a one-digit string value if the value of the TimeSpan.Hours property is 0 through 9, and it returns a two-digit string value if the value of the TimeSpan.Hours property ranges from 10 to 23.

Si el especificador de formato personalizado "f" se utiliza solo, especifique "%h" de modo que no se interprete erróneamente como una cadena de formato estándar.If the "h" custom format specifier is used alone, specify "%h" so that it is not misinterpreted as a standard format string. Esto se muestra en el ejemplo siguiente.The following example provides an illustration.

TimeSpan ts = new TimeSpan(3, 42, 0);
Console.WriteLine("{0:%h} hours {0:%m} minutes", ts);
// The example displays the following output:
//       3 hours 42 minutes
Dim ts As New TimeSpan(3, 42, 0)
Console.WriteLine("{0:%h} hours {0:%m} minutes", ts)
' The example displays the following output:
'       3 hours 42 minutes

Normalmente, en las operaciones de análisis, una cadena de entrada que incluye solamente un número se interpreta como número de días.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Se puede utilizar el especificador de formato personalizado "%h"" para que la cadena numérica se interprete como número de horas.You can use the "%h" custom format specifier instead to interpret the numeric string as the number of hours. Esto se muestra en el ejemplo siguiente.The following example provides an illustration.

string value = "8";
TimeSpan interval;
if (TimeSpan.TryParseExact(value, "%h", null, out interval))
   Console.WriteLine(interval.ToString("c"));
else
   Console.WriteLine("Unable to convert '{0}' to a time interval", 
                     value);   
// The example displays the following output:
//       08:00:00                              
Dim value As String = "8"
Dim interval As TimeSpan
If TimeSpan.TryParseExact(value, "%h", Nothing, interval) Then
   Console.WriteLine(interval.ToString("c"))
Else
   Console.WriteLine("Unable to convert '{0}' to a time interval", 
                     value)   
End If   
' The example displays the following output:
'       08:00:00                              

En el siguiente ejemplo, se muestra el uso del especificador de formato personalizado "h".The following example illustrates the use of the "h" custom format specifier.

TimeSpan ts1 = new TimeSpan(14, 3, 17);
Console.WriteLine(ts1.ToString(@"d\.h\:mm\:ss"));

TimeSpan ts2 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine(ts2.ToString(@"d\.h\:mm\:ss"));
// The example displays the following output:
//       0.14:03:17
//       3.4:03:17
Dim ts1 As New TimeSpan(14, 3, 17)
Console.WriteLine(ts1.ToString("d\.h\:mm\:ss"))

Dim ts2 As New TimeSpan(3, 4, 3, 17)
Console.WriteLine(ts2.ToString("d\.h\:mm\:ss"))
' The example displays the following output:
'       0.14:03:17
'       3.4:03:17

Volver a la tablaBack to table

Especificador de formato personalizado "hh"The "hh" Custom Format Specifier

El especificador de formato personalizado "hh" presenta el valor de la propiedad TimeSpan.Hours, que representa el número de horas completas de un intervalo de tiempo que no se cuentan como parte del componente de días.The "hh" custom format specifier outputs the value of the TimeSpan.Hours property, which represents the number of whole hours in the time interval that is not counted as part of its day component. Para los valores de 0 a 9, la cadena de salida incluye un cero inicial.For values from 0 through 9, the output string includes a leading zero.

Normalmente, en las operaciones de análisis, una cadena de entrada que incluye solamente un número se interpreta como número de días.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Se puede utilizar el especificador de formato personalizado "hh"" para que la cadena numérica se interprete como número de horas.You can use the "hh" custom format specifier instead to interpret the numeric string as the number of hours. Esto se muestra en el ejemplo siguiente.The following example provides an illustration.

string value = "08";
TimeSpan interval;
if (TimeSpan.TryParseExact(value, "hh", null, out interval))
   Console.WriteLine(interval.ToString("c"));
else
   Console.WriteLine("Unable to convert '{0}' to a time interval", 
                     value);   
// The example displays the following output:
//       08:00:00                              
Dim value As String = "08"
Dim interval As TimeSpan
If TimeSpan.TryParseExact(value, "hh", Nothing, interval) Then
   Console.WriteLine(interval.ToString("c"))
Else
   Console.WriteLine("Unable to convert '{0}' to a time interval", 
                     value)   
End If   
' The example displays the following output:
'       08:00:00                              

En el siguiente ejemplo, se muestra el uso del especificador de formato personalizado "hh".The following example illustrates the use of the "hh" custom format specifier.

TimeSpan ts1 = new TimeSpan(14, 3, 17);
Console.WriteLine(ts1.ToString(@"d\.hh\:mm\:ss"));

TimeSpan ts2 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine(ts2.ToString(@"d\.hh\:mm\:ss"));
// The example displays the following output:
//       0.14:03:17
//       3.04:03:17
Dim ts1 As New TimeSpan(14, 3, 17)
Console.WriteLine(ts1.ToString("d\.hh\:mm\:ss"))

Dim ts2 As New TimeSpan(3, 4, 3, 17)
Console.WriteLine(ts2.ToString("d\.hh\:mm\:ss"))
' The example displays the following output:
'       0.14:03:17
'       3.04:03:17

Volver a la tablaBack to table

Especificador de formato personalizado "m"The "m" Custom Format Specifier

El especificador de formato personalizado "m" presenta el valor de la propiedad TimeSpan.Minutes, que representa el número de minutos completos de un intervalo de tiempo que no se cuentan como parte del componente de días.The "m" custom format specifier outputs the value of the TimeSpan.Minutes property, which represents the number of whole minutes in the time interval that is not counted as part of its day component. Devuelve un valor de cadena de un dígito si el valor de la propiedad TimeSpan.Minutes es de 0 a 9; devuelve un valor de cadena de dos dígitos si el valor de la propiedad TimeSpan.Minutes es de 10 a 59.It returns a one-digit string value if the value of the TimeSpan.Minutes property is 0 through 9, and it returns a two-digit string value if the value of the TimeSpan.Minutes property ranges from 10 to 59.

Si el especificador de formato personalizado "m" se utiliza solo, especifique "%m" de modo que no se interprete erróneamente como una cadena de formato estándar.If the "m" custom format specifier is used alone, specify "%m" so that it is not misinterpreted as a standard format string. Esto se muestra en el ejemplo siguiente.The following example provides an illustration.

TimeSpan ts = new TimeSpan(3, 42, 0);
Console.WriteLine("{0:%h} hours {0:%m} minutes", ts);
// The example displays the following output:
//       3 hours 42 minutes
Dim ts As New TimeSpan(3, 42, 0)
Console.WriteLine("{0:%h} hours {0:%m} minutes", ts)
' The example displays the following output:
'       3 hours 42 minutes

Normalmente, en las operaciones de análisis, una cadena de entrada que incluye solamente un número se interpreta como número de días.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Se puede utilizar el especificador de formato personalizado "%m"" para que la cadena numérica se interprete como número de minutos.You can use the "%m" custom format specifier instead to interpret the numeric string as the number of minutes. Esto se muestra en el ejemplo siguiente.The following example provides an illustration.

string value = "3";
TimeSpan interval;
if (TimeSpan.TryParseExact(value, "%m", null, out interval))
   Console.WriteLine(interval.ToString("c"));
else
   Console.WriteLine("Unable to convert '{0}' to a time interval", 
                     value);   
// The example displays the following output:
//       00:03:00                              
Dim value As String = "3"
Dim interval As TimeSpan
If TimeSpan.TryParseExact(value, "%m", Nothing, interval) Then
   Console.WriteLine(interval.ToString("c"))
Else
   Console.WriteLine("Unable to convert '{0}' to a time interval", 
                     value)   
End If   
' The example displays the following output:
'       00:03:00                              

En el siguiente ejemplo, se muestra el uso del especificador de formato personalizado "m".The following example illustrates the use of the "m" custom format specifier.

TimeSpan ts1 = new TimeSpan(0, 6, 32);
Console.WriteLine("{0:m\\:ss} minutes", ts1);

TimeSpan ts2 = new TimeSpan(3, 4, 3, 17);
Console.WriteLine("Elapsed time: {0:m\\:ss}", ts2);
// The example displays the following output:
//       6:32 minutes
//       Elapsed time: 18:44
Dim ts1 As New TimeSpan(0, 6, 32)
Console.WriteLine("{0:m\:ss} minutes", ts1)

Dim ts2 As New TimeSpan(0, 18, 44)
Console.WriteLine("Elapsed time: {0:m\:ss}", ts2)
' The example displays the following output:
'       6:32 minutes
'       Elapsed time: 18:44

Volver a la tablaBack to table

Especificador de formato personalizado "mm"The "mm" Custom Format Specifier

El especificador de formato personalizado "mm" presenta el valor de la propiedad TimeSpan.Minutes, que representa el número de minutos completos de un intervalo de tiempo que no se cuentan como parte del componente de horas o días.The "mm" custom format specifier outputs the value of the TimeSpan.Minutes property, which represents the number of whole minutes in the time interval that is not included as part of its hours or days component. Para los valores de 0 a 9, la cadena de salida incluye un cero inicial.For values from 0 through 9, the output string includes a leading zero.

Normalmente, en las operaciones de análisis, una cadena de entrada que incluye solamente un número se interpreta como número de días.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Se puede utilizar el especificador de formato personalizado "mm"" para que la cadena numérica se interprete como número de minutos.You can use the "mm" custom format specifier instead to interpret the numeric string as the number of minutes. Esto se muestra en el ejemplo siguiente.The following example provides an illustration.

string value = "07";
TimeSpan interval;
if (TimeSpan.TryParseExact(value, "mm", null, out interval))
   Console.WriteLine(interval.ToString("c"));
else
   Console.WriteLine("Unable to convert '{0}' to a time interval", 
                     value);   
// The example displays the following output:
//       00:07:00                              
Dim value As String = "05"
Dim interval As TimeSpan
If TimeSpan.TryParseExact(value, "mm", Nothing, interval) Then
   Console.WriteLine(interval.ToString("c"))
Else
   Console.WriteLine("Unable to convert '{0}' to a time interval", 
                     value)   
End If   
' The example displays the following output:
'       00:05:00           

En el siguiente ejemplo, se muestra el uso del especificador de formato personalizado "mm".The following example illustrates the use of the "mm" custom format specifier.

TimeSpan departTime = new TimeSpan(11, 12, 00);
TimeSpan arriveTime = new TimeSpan(16, 28, 00);
Console.WriteLine("Travel time: {0:hh\\:mm}", 
                  arriveTime - departTime);
// The example displays the following output:
//       Travel time: 05:16      
Dim departTime As New TimeSpan(11, 12, 00)
Dim arriveTime As New TimeSpan(16, 28, 00)
Console.WriteLine("Travel time: {0:hh\:mm}", 
                  arriveTime - departTime)
' The example displays the following output:
'       Travel time: 05:16      

Volver a la tablaBack to table

Especificador de formato personalizado "s"The "s" Custom Format Specifier

El especificador de formato personalizado "s" presenta el valor de la propiedad TimeSpan.Seconds, que representa el número de segundos completos de un intervalo de tiempo que no se cuentan como parte del componente de horas, días o minutos.The "s" custom format specifier outputs the value of the TimeSpan.Seconds property, which represents the number of whole seconds in the time interval that is not included as part of its hours, days, or minutes component. Devuelve un valor de cadena de un dígito si el valor de la propiedad TimeSpan.Seconds es de 0 a 9; devuelve un valor de cadena de dos dígitos si el valor de la propiedad TimeSpan.Seconds es de 10 a 59.It returns a one-digit string value if the value of the TimeSpan.Seconds property is 0 through 9, and it returns a two-digit string value if the value of the TimeSpan.Seconds property ranges from 10 to 59.

Si el especificador de formato personalizado "s" se utiliza solo, especifique "%s" de modo que no se interprete erróneamente como una cadena de formato estándar.If the "s" custom format specifier is used alone, specify "%s" so that it is not misinterpreted as a standard format string. Esto se muestra en el ejemplo siguiente.The following example provides an illustration.

TimeSpan ts = TimeSpan.FromSeconds(12.465);
Console.WriteLine(ts.ToString("%s"));
// The example displays the following output:
//       12
Dim ts As TimeSpan = TimeSpan.FromSeconds(12.465)
Console.WriteLine(ts.ToString("%s"))
' The example displays the following output:
'       12

Normalmente, en las operaciones de análisis, una cadena de entrada que incluye solamente un número se interpreta como número de días.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Se puede utilizar el especificador de formato personalizado "%s"" para que la cadena numérica se interprete como número de segundos.You can use the "%s" custom format specifier instead to interpret the numeric string as the number of seconds. Esto se muestra en el ejemplo siguiente.The following example provides an illustration.

string value = "9";
TimeSpan interval;
if (TimeSpan.TryParseExact(value, "%s", null, out interval))
   Console.WriteLine(interval.ToString("c"));
else
   Console.WriteLine("Unable to convert '{0}' to a time interval", 
                     value);   
// The example displays the following output:
//       00:00:09
Dim value As String = "9"
Dim interval As TimeSpan
If TimeSpan.TryParseExact(value, "%s", Nothing, interval) Then
   Console.WriteLine(interval.ToString("c"))
Else
   Console.WriteLine("Unable to convert '{0}' to a time interval", 
                     value)   
End If   
' The example displays the following output:
'       00:00:09

En el siguiente ejemplo, se muestra el uso del especificador de formato personalizado "s".The following example illustrates the use of the "s" custom format specifier.

TimeSpan startTime = new TimeSpan(0, 12, 30, 15, 0);
TimeSpan endTime = new TimeSpan(0, 12, 30, 21, 3);
Console.WriteLine(@"Elapsed Time: {0:s\:fff} seconds", 
                  endTime - startTime);
// The example displays the following output:
//       Elapsed Time: 6:003 seconds      
Dim startTime As New TimeSpan(0, 12, 30, 15, 0)
Dim endTime As New TimeSpan(0, 12, 30, 21, 3)
Console.WriteLine("Elapsed Time: {0:s\:fff} seconds", 
                  endTime - startTime)
' The example displays the following output:
'       Elapsed Time: 6:003 seconds      

Volver a la tablaBack to table

Especificador de formato personalizado "ss"The "ss" Custom Format Specifier

El especificador de formato personalizado "ss" presenta el valor de la propiedad TimeSpan.Seconds, que representa el número de segundos completos de un intervalo de tiempo que no se cuentan como parte del componente de horas, días o minutos.The "ss" custom format specifier outputs the value of the TimeSpan.Seconds property, which represents the number of whole seconds in the time interval that is not included as part of its hours, days, or minutes component. Para los valores de 0 a 9, la cadena de salida incluye un cero inicial.For values from 0 through 9, the output string includes a leading zero.

Normalmente, en las operaciones de análisis, una cadena de entrada que incluye solamente un número se interpreta como número de días.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Se puede utilizar el especificador de formato personalizado "ss"" para que la cadena numérica se interprete como número de segundos.You can use the "ss" custom format specifier instead to interpret the numeric string as the number of seconds. Esto se muestra en el ejemplo siguiente.The following example provides an illustration.

string[] values = { "49", "9", "06" };
TimeSpan interval;
foreach (string value in values)
{
   if (TimeSpan.TryParseExact(value, "ss", null, out interval))
      Console.WriteLine(interval.ToString("c"));
   else
      Console.WriteLine("Unable to convert '{0}' to a time interval", 
                        value);   
}
// The example displays the following output:
//       00:00:49
//       Unable to convert '9' to a time interval
//       00:00:06
Dim values() As String = { "49", "9", "06" }
Dim interval As TimeSpan
For Each value As String In values
   If TimeSpan.TryParseExact(value, "ss", Nothing, interval) Then
      Console.WriteLine(interval.ToString("c"))
   Else
      Console.WriteLine("Unable to convert '{0}' to a time interval", 
                        value)   
   End If   
Next   
' The example displays the following output:
'       00:00:49
'       Unable to convert '9' to a time interval
'       00:00:06

En el siguiente ejemplo, se muestra el uso del especificador de formato personalizado "ss".The following example illustrates the use of the "ss" custom format specifier.

TimeSpan interval1 = TimeSpan.FromSeconds(12.60);
Console.WriteLine(interval1.ToString(@"ss\.fff"));

TimeSpan interval2 = TimeSpan.FromSeconds(6.485);
Console.WriteLine(interval2.ToString(@"ss\.fff"));
// The example displays the following output:
//       12.600
//       06.485
Dim interval1 As TimeSpan = TimeSpan.FromSeconds(12.60)
Console.WriteLine(interval1.ToString("ss\.fff"))
Dim interval2 As TimeSpan = TimeSpan.FromSeconds(6.485)
Console.WriteLine(interval2.ToString("ss\.fff"))
' The example displays the following output:
'       12.600
'       06.485

Volver a la tablaBack to table

Especificador de formato personalizado "f"The"f" Custom Format Specifier

El especificador de formato personalizado "f" presenta las décimas de segundo de un intervalo de tiempo.The "f" custom format specifier outputs the tenths of a second in a time interval. En una operación de formato, se truncan los dígitos fraccionarios restantes.In a formatting operation, any remaining fractional digits are truncated. En una operación de análisis que llama al método TimeSpan.ParseExact o TimeSpan.TryParseExact, la cadena de entrada debe contener exactamente un dígito fraccionario.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly one fractional digit.

Si el especificador de formato personalizado "f" se utiliza solo, especifique "%f" de modo que no se interprete erróneamente como una cadena de formato estándar.If the "f" custom format specifier is used alone, specify "%f" so that it is not misinterpreted as a standard format string.

En el siguiente ejemplo, se utiliza el especificador de formato personalizado "f" para mostrar las décimas de segundo de un valor TimeSpan.The following example uses the "f" custom format specifier to display the tenths of a second in a TimeSpan value. "f" se usa primero solo y luego junto con el especificador "s" en una cadena de formato personalizado."f" is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();
 
for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts);
} 
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   Console.WriteLine("{0,10}: {1:s\\." + fmt + "}", "s\\." + fmt, ts);
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//       
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432      
Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()
 
For ctr = 1 To 7
   fmt = New String("f"c, ctr)
   If fmt.Length = 1 Then fmt = "%" + fmt
   Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next 
Console.WriteLine()

For ctr = 1 To 7
   fmt = New String("f"c, ctr)
   Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Volver a la tablaBack to table

Especificador de formato personalizado "ff"The "ff" Custom Format Specifier

El especificador de formato personalizado "ff" presenta las centésimas de segundo de un intervalo de tiempo.The "ff" custom format specifier outputs the hundredths of a second in a time interval. En una operación de formato, se truncan los dígitos fraccionarios restantes.In a formatting operation, any remaining fractional digits are truncated. En una operación de análisis que llama al método TimeSpan.ParseExact o TimeSpan.TryParseExact, la cadena de entrada debe contener exactamente dos dígitos fraccionarios.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly two fractional digits.

En el siguiente ejemplo, se utiliza el especificador de formato personalizado "ff" para mostrar las centésimas de segundo de un valor TimeSpan.The following example uses the "ff" custom format specifier to display the hundredths of a second in a TimeSpan value. "ff" se usa primero solo luego junto con el especificador "s" en una cadena de formato personalizado."ff" is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();
 
for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts);
} 
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   Console.WriteLine("{0,10}: {1:s\\." + fmt + "}", "s\\." + fmt, ts);
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//       
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432      
Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()
 
For ctr = 1 To 7
   fmt = New String("f"c, ctr)
   If fmt.Length = 1 Then fmt = "%" + fmt
   Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next 
Console.WriteLine()

For ctr = 1 To 7
   fmt = New String("f"c, ctr)
   Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Volver a la tablaBack to table

Especificador de formato personalizado "fff"The "fff" Custom Format Specifier

El especificador de formato personalizado "fff" (tres caracteres "f") presenta las milésimas de segundo de un intervalo de tiempo.The "fff" custom format specifier (with three "f" characters) outputs the milliseconds in a time interval. En una operación de formato, se truncan los dígitos fraccionarios restantes.In a formatting operation, any remaining fractional digits are truncated. En una operación de análisis que llama al método TimeSpan.ParseExact o TimeSpan.TryParseExact, la cadena de entrada debe contener exactamente tres dígitos fraccionarios.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly three fractional digits.

En el siguiente ejemplo, se utiliza el especificador de formato personalizado "fff" para mostrar los milisegundos de un valor TimeSpan.The following example uses the "fff" custom format specifier to display the milliseconds in a TimeSpan value. "fff" se usa primero solo y luego junto con el especificador "s" en una cadena de formato personalizado."fff" is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();
 
for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts);
} 
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   Console.WriteLine("{0,10}: {1:s\\." + fmt + "}", "s\\." + fmt, ts);
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//       
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432      
Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()
 
For ctr = 1 To 7
   fmt = New String("f"c, ctr)
   If fmt.Length = 1 Then fmt = "%" + fmt
   Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next 
Console.WriteLine()

For ctr = 1 To 7
   fmt = New String("f"c, ctr)
   Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Volver a la tablaBack to table

Especificador de formato personalizado "ffff"The "ffff" Custom Format Specifier

El especificador de formato personalizado "ffff" (cuatro caracteres "f") presenta las diezmilésimas de segundo de un intervalo de tiempo.The "ffff" custom format specifier (with four "f" characters) outputs the ten-thousandths of a second in a time interval. En una operación de formato, se truncan los dígitos fraccionarios restantes.In a formatting operation, any remaining fractional digits are truncated. En una operación de análisis que llama al método TimeSpan.ParseExact o TimeSpan.TryParseExact, la cadena de entrada debe contener exactamente cuatro dígitos fraccionarios.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly four fractional digits.

En el siguiente ejemplo, se utiliza el especificador de formato personalizado "ffff" para mostrar las diezmilésimas de segundo de un valor TimeSpan.The following example uses the "ffff" custom format specifier to display the ten-thousandths of a second in a TimeSpan value. "ffff" se usa primero solo y luego junto con el especificador "s" en una cadena de formato personalizado."ffff" is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();
 
for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts);
} 
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   Console.WriteLine("{0,10}: {1:s\\." + fmt + "}", "s\\." + fmt, ts);
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//       
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432      
Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()
 
For ctr = 1 To 7
   fmt = New String("f"c, ctr)
   If fmt.Length = 1 Then fmt = "%" + fmt
   Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next 
Console.WriteLine()

For ctr = 1 To 7
   fmt = New String("f"c, ctr)
   Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Volver a la tablaBack to table

Especificador de formato personalizado "fffff"The "fffff" Custom Format Specifier

El especificador de formato personalizado "fffff" (cinco caracteres "f") presenta las cienmilésimas de segundo de un intervalo de tiempo.The "fffff" custom format specifier (with five "f" characters) outputs the hundred-thousandths of a second in a time interval. En una operación de formato, se truncan los dígitos fraccionarios restantes.In a formatting operation, any remaining fractional digits are truncated. En una operación de análisis que llama al método TimeSpan.ParseExact o TimeSpan.TryParseExact, la cadena de entrada debe contener exactamente cinco dígitos fraccionarios.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly five fractional digits.

En el siguiente ejemplo, se utiliza el especificador de formato personalizado "fffff" para mostrar las cienmilésimas de segundo de un valor TimeSpan.The following example uses the "fffff" custom format specifier to display the hundred-thousandths of a second in a TimeSpan value. "fffff" se usa primero solo y luego junto con el especificador "s" en una cadena de formato personalizado."fffff" is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();
 
for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts);
} 
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   Console.WriteLine("{0,10}: {1:s\\." + fmt + "}", "s\\." + fmt, ts);
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//       
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432      
Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()
 
For ctr = 1 To 7
   fmt = New String("f"c, ctr)
   If fmt.Length = 1 Then fmt = "%" + fmt
   Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next 
Console.WriteLine()

For ctr = 1 To 7
   fmt = New String("f"c, ctr)
   Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Volver a la tablaBack to table

Especificador de formato personalizado "ffffff"The "ffffff" Custom Format Specifier

El especificador de formato personalizado "ffffff" (seis caracteres "f") presenta las millonésimas de segundo de un intervalo de tiempo.The "ffffff" custom format specifier (with six "f" characters) outputs the millionths of a second in a time interval. En una operación de formato, se truncan los dígitos fraccionarios restantes.In a formatting operation, any remaining fractional digits are truncated. En una operación de análisis que llama al método TimeSpan.ParseExact o TimeSpan.TryParseExact, la cadena de entrada debe contener exactamente seis dígitos fraccionarios.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly six fractional digits.

En el siguiente ejemplo, se utiliza el especificador de formato personalizado "ffffff" para mostrar las millonésimas de segundo de un valor TimeSpan.The following example uses the "ffffff" custom format specifier to display the millionths of a second in a TimeSpan value. Este especificador de formato se utiliza primero solo y, a continuación, junto con el especificador "s" en una cadena de formato personalizado.It is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();
 
for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts);
} 
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   Console.WriteLine("{0,10}: {1:s\\." + fmt + "}", "s\\." + fmt, ts);
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//       
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432      
Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()
 
For ctr = 1 To 7
   fmt = New String("f"c, ctr)
   If fmt.Length = 1 Then fmt = "%" + fmt
   Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next 
Console.WriteLine()

For ctr = 1 To 7
   fmt = New String("f"c, ctr)
   Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Volver a la tablaBack to table

Especificador de formato personalizado "fffffff"The "fffffff" Custom Format Specifier

El especificador de formato personalizado "fffffff" (siete caracteres "f") presenta las diezmillonésimas de segundo (o fracciones de paso) de un intervalo de tiempo.The "fffffff" custom format specifier (with seven "f" characters) outputs the ten-millionths of a second (or the fractional number of ticks) in a time interval. En una operación de análisis que llama al método TimeSpan.ParseExact o TimeSpan.TryParseExact, la cadena de entrada debe contener exactamente siete dígitos fraccionarios.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly seven fractional digits.

En el siguiente ejemplo, se utiliza el especificador de formato personalizado "fffffff" para mostrar las fracciones de paso de un valor TimeSpan.The following example uses the "fffffff" custom format specifier to display the fractional number of ticks in a TimeSpan value. Este especificador de formato se utiliza primero solo y, a continuación, junto con el especificador "s" en una cadena de formato personalizado.It is used first as the only format specifier, and then combined with the "s" specifier in a custom format string.

TimeSpan ts = new TimeSpan(1003498765432);
string fmt;
Console.WriteLine(ts.ToString("c"));
Console.WriteLine();
 
for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   if (fmt.Length == 1) fmt = "%" + fmt;
   Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts);
} 
Console.WriteLine();

for (int ctr = 1; ctr <= 7; ctr++) {
   fmt = new String('f', ctr);
   Console.WriteLine("{0,10}: {1:s\\." + fmt + "}", "s\\." + fmt, ts);
}
// The example displays the following output:
//               %f: 8
//               ff: 87
//              fff: 876
//             ffff: 8765
//            fffff: 87654
//           ffffff: 876543
//          fffffff: 8765432
//       
//              s\.f: 29.8
//             s\.ff: 29.87
//            s\.fff: 29.876
//           s\.ffff: 29.8765
//          s\.fffff: 29.87654
//         s\.ffffff: 29.876543
//        s\.fffffff: 29.8765432      
Dim ts As New TimeSpan(1003498765432)
Dim fmt As String
Console.WriteLine(ts.ToString("c"))
Console.WriteLine()
 
For ctr = 1 To 7
   fmt = New String("f"c, ctr)
   If fmt.Length = 1 Then fmt = "%" + fmt
   Console.WriteLine("{0,10}: {1:" + fmt + "}", fmt, ts)
Next 
Console.WriteLine()

For ctr = 1 To 7
   fmt = New String("f"c, ctr)
   Console.WriteLine("{0,10}: {1:s\." + fmt + "}", "s\." + fmt, ts)
Next
' The example displays the following output:
'            %f: 8
'            ff: 87
'           fff: 876
'          ffff: 8765
'         fffff: 87654
'        ffffff: 876543
'       fffffff: 8765432
'    
'           s\.f: 29.8
'          s\.ff: 29.87
'         s\.fff: 29.876
'        s\.ffff: 29.8765
'       s\.fffff: 29.87654
'      s\.ffffff: 29.876543
'     s\.fffffff: 29.8765432

Volver a la tablaBack to table

Especificador de formato personalizado "F"The "F" Custom Format Specifier

El especificador de formato personalizado "F" presenta las décimas de segundo de un intervalo de tiempo.The "F" custom format specifier outputs the tenths of a second in a time interval. En una operación de formato, se truncan los dígitos fraccionarios restantes.In a formatting operation, any remaining fractional digits are truncated. Si el valor de las décimas de segundo de un intervalo de tiempo es cero, no se incluirá en la cadena de resultado.If the value of the time interval's tenths of a second is zero, it is not included in the result string. En una operación de análisis que llama al método TimeSpan.ParseExact o TimeSpan.TryParseExact, la presencia de las décimas de segundo es opcional.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths of a second digit is optional.

Si el especificador de formato personalizado "F" se utiliza solo, especifique "%F" de modo que no se interprete erróneamente como una cadena de formato estándar.If the "F" custom format specifier is used alone, specify "%F" so that it is not misinterpreted as a standard format string.

En el siguiente ejemplo, se utiliza el especificador de formato personalizado "F" para mostrar las décimas de segundo de un valor TimeSpan.The following example uses the "F" custom format specifier to display the tenths of a second in a TimeSpan value. También se utiliza este especificador de formato personalizado en una operación de análisis.It also uses this custom format specifier in a parsing operation.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.669");
Console.WriteLine("{0} ('%F') --> {0:%F}", ts1);

TimeSpan ts2 = TimeSpan.Parse("0:0:3.091");
Console.WriteLine("{0} ('ss\\.F') --> {0:ss\\.F}", ts2);
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.1", "0:0:03.12" };
string fmt = @"h\:m\:ss\.F";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3);
   else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, fmt);
}                        
// The example displays the following output:
//       Formatting:
//       00:00:03.6690000 ('%F') --> 6
//       00:00:03.0910000 ('ss\.F') --> 03.
//       
//       Parsing:
//       0:0:03. ('h\:m\:ss\.F') --> 00:00:03
//       0:0:03.1 ('h\:m\:ss\.F') --> 00:00:03.1000000
//       Cannot parse 0:0:03.12 with 'h\:m\:ss\.F'.      
Console.WriteLine("Formatting:")
Dim ts1 As TimeSpan = TimeSpan.Parse("0:0:3.669")
Console.WriteLine("{0} ('%F') --> {0:%F}", ts1)

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.091")
Console.WriteLine("{0} ('ss\.F') --> {0:ss\.F}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = { "0:0:03.", "0:0:03.1", "0:0:03.12" }
Dim fmt As String = "h\:m\:ss\.F"
Dim ts3 As TimeSpan

For Each input As String In inputs
   If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
      Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
   Else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, fmt)
   End If  
Next
' The example displays the following output:
'       Formatting:
'       00:00:03.6690000 ('%F') --> 6
'       00:00:03.0910000 ('ss\.F') --> 03.
'       
'       Parsing:
'       0:0:03. ('h\:m\:ss\.F') --> 00:00:03
'       0:0:03.1 ('h\:m\:ss\.F') --> 00:00:03.1000000
'       Cannot parse 0:0:03.12 with 'h\:m\:ss\.F'.      

Volver a la tablaBack to table

Especificador de formato personalizado "FF"The "FF" Custom Format Specifier

El especificador de formato personalizado "FF" presenta las centésimas de segundo de un intervalo de tiempo.The "FF" custom format specifier outputs the hundredths of a second in a time interval. En una operación de formato, se truncan los dígitos fraccionarios restantes.In a formatting operation, any remaining fractional digits are truncated. Si hay ceros fraccionarios finales, estos no se incluyen en la cadena de resultado.If there are any trailing fractional zeros, they are not included in the result string. En una operación de análisis que llama al método TimeSpan.ParseExact o TimeSpan.TryParseExact, la presencia de las décimas y centésimas de segundo es opcional.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths and hundredths of a second digit is optional.

En el siguiente ejemplo, se utiliza el especificador de formato personalizado "FF" para mostrar las centésimas de segundo de un valor TimeSpan.The following example uses the "FF" custom format specifier to display the hundredths of a second in a TimeSpan value. También se utiliza este especificador de formato personalizado en una operación de análisis.It also uses this custom format specifier in a parsing operation.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.697");
Console.WriteLine("{0} ('FF') --> {0:FF}", ts1);

TimeSpan ts2 = TimeSpan.Parse("0:0:3.809");
Console.WriteLine("{0} ('ss\\.FF') --> {0:ss\\.FF}", ts2);
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.1", "0:0:03.127" };
string fmt = @"h\:m\:ss\.FF";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3);
   else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, fmt);
}
// The example displays the following output:
//       Formatting:
//       00:00:03.6970000 ('FF') --> 69
//       00:00:03.8090000 ('ss\.FF') --> 03.8
//       
//       Parsing:
//       0:0:03. ('h\:m\:ss\.FF') --> 00:00:03
//       0:0:03.1 ('h\:m\:ss\.FF') --> 00:00:03.1000000
//       Cannot parse 0:0:03.127 with 'h\:m\:ss\.FF'.      
Console.WriteLine("Formatting:")
Dim ts1 As TimeSpan = TimeSpan.Parse("0:0:3.697")
Console.WriteLine("{0} ('FF') --> {0:FF}", ts1)

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.809")
Console.WriteLine("{0} ('ss\.FF') --> {0:ss\.FF}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = { "0:0:03.", "0:0:03.1", "0:0:03.127" }
Dim fmt As String = "h\:m\:ss\.FF"
Dim ts3 As TimeSpan

For Each input As String In inputs
   If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
      Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
   Else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, fmt)
   End If  
Next
' The example displays the following output:
'       Formatting:
'       00:00:03.6970000 ('FF') --> 69
'       00:00:03.8090000 ('ss\.FF') --> 03.8
'       
'       Parsing:
'       0:0:03. ('h\:m\:ss\.FF') --> 00:00:03
'       0:0:03.1 ('h\:m\:ss\.FF') --> 00:00:03.1000000
'       Cannot parse 0:0:03.127 with 'h\:m\:ss\.FF'.

Volver a la tablaBack to table

Especificador de formato personalizado "FFF"The "FFF" Custom Format Specifier

El especificador de formato personalizado "FFF" (tres caracteres "F") presenta las milésimas de segundo de un intervalo de tiempo.The "FFF" custom format specifier (with three "F" characters) outputs the milliseconds in a time interval. En una operación de formato, se truncan los dígitos fraccionarios restantes.In a formatting operation, any remaining fractional digits are truncated. Si hay ceros fraccionarios finales, estos no se incluyen en la cadena de resultado.If there are any trailing fractional zeros, they are not included in the result string. En una operación de análisis que llama al método TimeSpan.ParseExact o TimeSpan.TryParseExact, la presencia de las décimas, centésimas y milésimas de segundo es opcional.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths, hundredths, and thousandths of a second digit is optional.

En el siguiente ejemplo, se utiliza el especificador de formato personalizado "FFF" para mostrar las milésimas de segundo de un valor TimeSpan.The following example uses the "FFF" custom format specifier to display the thousandths of a second in a TimeSpan value. También se utiliza este especificador de formato personalizado en una operación de análisis.It also uses this custom format specifier in a parsing operation.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.6974");
Console.WriteLine("{0} ('FFF') --> {0:FFF}", ts1);

TimeSpan ts2 = TimeSpan.Parse("0:0:3.8009");
Console.WriteLine("{0} ('ss\\.FFF') --> {0:ss\\.FFF}", ts2);
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.12", "0:0:03.1279" };
string fmt = @"h\:m\:ss\.FFF";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3);
   else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, fmt);
}
// The example displays the following output:
//       Formatting:
//       00:00:03.6974000 ('FFF') --> 697
//       00:00:03.8009000 ('ss\.FFF') --> 03.8
//       
//       Parsing:
//       0:0:03. ('h\:m\:ss\.FFF') --> 00:00:03
//       0:0:03.12 ('h\:m\:ss\.FFF') --> 00:00:03.1200000
//       Cannot parse 0:0:03.1279 with 'h\:m\:ss\.FFF'.      
Console.WriteLine("Formatting:")
Dim ts1 As TimeSpan = TimeSpan.Parse("0:0:3.6974")
Console.WriteLine("{0} ('FFF') --> {0:FFF}", ts1)

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.8009")
Console.WriteLine("{0} ('ss\.FFF') --> {0:ss\.FFF}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = { "0:0:03.", "0:0:03.12", "0:0:03.1279" }
Dim fmt As String = "h\:m\:ss\.FFF"
Dim ts3 As TimeSpan

For Each input As String In inputs
   If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
      Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
   Else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, fmt)
   End If  
Next
' The example displays the following output:
'       Formatting:
'       00:00:03.6974000 ('FFF') --> 697
'       00:00:03.8009000 ('ss\.FFF') --> 03.8
'       
'       Parsing:
'       0:0:03. ('h\:m\:ss\.FFF') --> 00:00:03
'       0:0:03.12 ('h\:m\:ss\.FFF') --> 00:00:03.1200000
'       Cannot parse 0:0:03.1279 with 'h\:m\:ss\.FFF'.

Volver a la tablaBack to table

Especificador de formato personalizado "FFFF"The "FFFF" Custom Format Specifier

El especificador de formato personalizado "FFFF" (cuatro caracteres "F") presenta las diezmilésimas de segundo de un intervalo de tiempo.The "FFFF" custom format specifier (with four "F" characters) outputs the ten-thousandths of a second in a time interval. En una operación de formato, se truncan los dígitos fraccionarios restantes.In a formatting operation, any remaining fractional digits are truncated. Si hay ceros fraccionarios finales, estos no se incluyen en la cadena de resultado.If there are any trailing fractional zeros, they are not included in the result string. En una operación de análisis que llama al método TimeSpan.ParseExact o TimeSpan.TryParseExact, la presencia de las décimas, centésimas, milésimas y diezmilésimas de segundo es opcional.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths, hundredths, thousandths, and ten-thousandths of a second digit is optional.

En el siguiente ejemplo, se utiliza el especificador de formato personalizado "FFFF" para mostrar las diezmilésimas de segundo de un valor TimeSpan.The following example uses the "FFFF" custom format specifier to display the ten-thousandths of a second in a TimeSpan value. También se utiliza este especificador de formato personalizado en una operación de análisis.It also uses the "FFFF" custom format specifier in a parsing operation.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.69749");
Console.WriteLine("{0} ('FFFF') --> {0:FFFF}", ts1);

TimeSpan ts2 = TimeSpan.Parse("0:0:3.80009");
Console.WriteLine("{0} ('ss\\.FFFF') --> {0:ss\\.FFFF}", ts2);
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.12", "0:0:03.12795" };
string fmt = @"h\:m\:ss\.FFFF";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3);
   else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, fmt);
}
// The example displays the following output:
//       Formatting:
//       00:00:03.6974900 ('FFFF') --> 6974
//       00:00:03.8000900 ('ss\.FFFF') --> 03.8
//       
//       Parsing:
//       0:0:03. ('h\:m\:ss\.FFFF') --> 00:00:03
//       0:0:03.12 ('h\:m\:ss\.FFFF') --> 00:00:03.1200000
//       Cannot parse 0:0:03.12795 with 'h\:m\:ss\.FFFF'.
Console.WriteLine("Formatting:")
Dim ts1 As TimeSpan = TimeSpan.Parse("0:0:3.69749")
Console.WriteLine("{0} ('FFFF') --> {0:FFFF}", ts1)

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.80009")
Console.WriteLine("{0} ('ss\.FFFF') --> {0:ss\.FFFF}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = { "0:0:03.", "0:0:03.12", "0:0:03.12795" }
Dim fmt As String = "h\:m\:ss\.FFFF"
Dim ts3 As TimeSpan

For Each input As String In inputs
   If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
      Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
   Else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, fmt)
   End If  
Next
' The example displays the following output:
'       Formatting:
'       00:00:03.6974900 ('FFFF') --> 6974
'       00:00:03.8000900 ('ss\.FFFF') --> 03.8
'       
'       Parsing:
'       0:0:03. ('h\:m\:ss\.FFFF') --> 00:00:03
'       0:0:03.12 ('h\:m\:ss\.FFFF') --> 00:00:03.1200000
'       Cannot parse 0:0:03.12795 with 'h\:m\:ss\.FFFF'.

Volver a la tablaBack to table

Especificador de formato personalizado "FFFFF"The "FFFFF" Custom Format Specifier

El especificador de formato personalizado "FFFFF" (cinco caracteres "F") presenta las cienmilésimas de segundo de un intervalo de tiempo.The "FFFFF" custom format specifier (with five "F" characters) outputs the hundred-thousandths of a second in a time interval. En una operación de formato, se truncan los dígitos fraccionarios restantes.In a formatting operation, any remaining fractional digits are truncated. Si hay ceros fraccionarios finales, estos no se incluyen en la cadena de resultado.If there are any trailing fractional zeros, they are not included in the result string. En una operación de análisis que llama al método TimeSpan.ParseExact o TimeSpan.TryParseExact, la presencia de las décimas, centésimas, milésimas, diezmilésimas y cienmilésimas de segundo es opcional.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths, hundredths, thousandths, ten-thousandths, and hundred-thousandths of a second digit is optional.

En el siguiente ejemplo, se utiliza el especificador de formato personalizado "FFFFF" para mostrar las cienmilésimas de segundo de un valor TimeSpan.The following example uses the "FFFFF" custom format specifier to display the hundred-thousandths of a second in a TimeSpan value. También se utiliza este especificador de formato personalizado en una operación de análisis.It also uses the "FFFFF" custom format specifier in a parsing operation.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.697497");
Console.WriteLine("{0} ('FFFFF') --> {0:FFFFF}", ts1);

TimeSpan ts2 = TimeSpan.Parse("0:0:3.800009");
Console.WriteLine("{0} ('ss\\.FFFFF') --> {0:ss\\.FFFFF}", ts2);
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.12", "0:0:03.127956" };
string fmt = @"h\:m\:ss\.FFFFF";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3);
   else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, fmt);
}                       
// The example displays the following output:
//       Formatting:
//       00:00:03.6974970 ('FFFFF') --> 69749
//       00:00:03.8000090 ('ss\.FFFFF') --> 03.8
//       
//       Parsing:
//       0:0:03. ('h\:m\:ss\.FFFF') --> 00:00:03
//       0:0:03.12 ('h\:m\:ss\.FFFF') --> 00:00:03.1200000
//       Cannot parse 0:0:03.127956 with 'h\:m\:ss\.FFFF'.      
Console.WriteLine("Formatting:")
Dim ts1 As TimeSpan = TimeSpan.Parse("0:0:3.697497")
Console.WriteLine("{0} ('FFFFF') --> {0:FFFFF}", ts1)

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.800009")
Console.WriteLine("{0} ('ss\.FFFFF') --> {0:ss\.FFFFF}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = { "0:0:03.", "0:0:03.12", "0:0:03.127956" }
Dim fmt As String = "h\:m\:ss\.FFFFF"
Dim ts3 As TimeSpan

For Each input As String In inputs
   If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
      Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
   Else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, fmt)
   End If  
Next
' The example displays the following output:
'       Formatting:
'       00:00:03.6974970 ('FFFFF') --> 69749
'       00:00:03.8000090 ('ss\.FFFFF') --> 03.8
'       
'       Parsing:
'       0:0:03. ('h\:m\:ss\.FFFF') --> 00:00:03
'       0:0:03.12 ('h\:m\:ss\.FFFF') --> 00:00:03.1200000
'       Cannot parse 0:0:03.127956 with 'h\:m\:ss\.FFFF'.

Volver a la tablaBack to table

Especificador de formato personalizado "FFFFFF"The "FFFFFF" Custom Format Specifier

El especificador de formato personalizado "FFFFFF" (seis caracteres "F") presenta las millonésimas de segundo de un intervalo de tiempo.The "FFFFFF" custom format specifier (with six "F" characters) outputs the millionths of a second in a time interval. En una operación de formato, se truncan los dígitos fraccionarios restantes.In a formatting operation, any remaining fractional digits are truncated. Si hay ceros fraccionarios finales, estos no se incluyen en la cadena de resultado.If there are any trailing fractional zeros, they are not included in the result string. En una operación de análisis que llama al método TimeSpan.ParseExact o TimeSpan.TryParseExact, la presencia de las décimas, centésimas, milésimas, diezmilésimas, cienmilésimas y millonésimas de segundo es opcional.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the tenths, hundredths, thousandths, ten-thousandths, hundred-thousandths, and millionths of a second digit is optional.

En el siguiente ejemplo, se utiliza el especificador de formato personalizado "FFFFFF" para mostrar las millonésimas de segundo de un valor TimeSpan.The following example uses the "FFFFFF" custom format specifier to display the millionths of a second in a TimeSpan value. También se utiliza este especificador de formato personalizado en una operación de análisis.It also uses this custom format specifier in a parsing operation.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.6974974");
Console.WriteLine("{0} ('FFFFFF') --> {0:FFFFFF}", ts1);

TimeSpan ts2 = TimeSpan.Parse("0:0:3.8000009");
Console.WriteLine("{0} ('ss\\.FFFFFF') --> {0:ss\\.FFFFFF}", ts2);
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.12", "0:0:03.1279569" };
string fmt = @"h\:m\:ss\.FFFFFF";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3);
   else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, fmt);
}                       
// The example displays the following output:
//       Formatting:
//       00:00:03.6974974 ('FFFFFF') --> 697497
//       00:00:03.8000009 ('ss\.FFFFFF') --> 03.8
//       
//       Parsing:
//       0:0:03. ('h\:m\:ss\.FFFFFF') --> 00:00:03
//       0:0:03.12 ('h\:m\:ss\.FFFFFF') --> 00:00:03.1200000
//       Cannot parse 0:0:03.1279569 with 'h\:m\:ss\.FFFFFF'.      
Console.WriteLine("Formatting:")
Dim ts1 As TimeSpan = TimeSpan.Parse("0:0:3.6974974")
Console.WriteLine("{0} ('FFFFFF') --> {0:FFFFFF}", ts1)

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.8000009")
Console.WriteLine("{0} ('ss\.FFFFFF') --> {0:ss\.FFFFFF}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = { "0:0:03.", "0:0:03.12", "0:0:03.1279569" }
Dim fmt As String = "h\:m\:ss\.FFFFFF"
Dim ts3 As TimeSpan

For Each input As String In inputs
   If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
      Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
   Else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, fmt)
   End If  
Next
' The example displays the following output:
'       Formatting:
'       00:00:03.6974974 ('FFFFFF') --> 697497
'       00:00:03.8000009 ('ss\.FFFFFF') --> 03.8
'       
'       Parsing:
'       0:0:03. ('h\:m\:ss\.FFFFFF') --> 00:00:03
'       0:0:03.12 ('h\:m\:ss\.FFFFFF') --> 00:00:03.1200000
'       Cannot parse 0:0:03.1279569 with 'h\:m\:ss\.FFFFFF'.

Volver a la tablaBack to table

Especificador de formato personalizado "FFFFFFF"The "FFFFFFF" Custom Format Specifier

El especificador de formato personalizado "FFFFFFF" (siete caracteres "F") presenta las diezmillonésimas de segundo (o fracciones de paso) de un intervalo de tiempo.The "FFFFFFF" custom format specifier (with seven "F" characters) outputs the ten-millionths of a second (or the fractional number of ticks) in a time interval. Si hay ceros fraccionarios finales, estos no se incluyen en la cadena de resultado.If there are any trailing fractional zeros, they are not included in the result string. En una operación de análisis que llama al método TimeSpan.ParseExact or TimeSpan.TryParseExact, la presencia de los siete dígitos fraccionarios en la cadena de entrada es opcional.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the presence of the seven fractional digits in the input string is optional.

En el siguiente ejemplo, se utiliza el especificador de formato personalizado "FFFFFFF" para mostrar las fracciones de segundo de un valor TimeSpan.The following example uses the "FFFFFFF" custom format specifier to display the fractional parts of a second in a TimeSpan value. También se utiliza este especificador de formato personalizado en una operación de análisis.It also uses this custom format specifier in a parsing operation.

Console.WriteLine("Formatting:");
TimeSpan ts1 = TimeSpan.Parse("0:0:3.6974974");
Console.WriteLine("{0} ('FFFFFFF') --> {0:FFFFFFF}", ts1);

TimeSpan ts2 = TimeSpan.Parse("0:0:3.9500000");
Console.WriteLine("{0} ('ss\\.FFFFFFF') --> {0:ss\\.FFFFFFF}", ts2);
Console.WriteLine();

Console.WriteLine("Parsing:");
string[] inputs = { "0:0:03.", "0:0:03.12", "0:0:03.1279569" };
string fmt = @"h\:m\:ss\.FFFFFFF";
TimeSpan ts3;

foreach (string input in inputs) {
   if (TimeSpan.TryParseExact(input, fmt, null, out ts3))
      Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3);
   else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, fmt);
}
// The example displays the following output:
//    Formatting:
//    00:00:03.6974974 ('FFFFFFF') --> 6974974
//    00:00:03.9500000 ('ss\.FFFFFFF') --> 03.95
//    
//    Parsing:
//    0:0:03. ('h\:m\:ss\.FFFFFFF') --> 00:00:03
//    0:0:03.12 ('h\:m\:ss\.FFFFFFF') --> 00:00:03.1200000
//    0:0:03.1279569 ('h\:m\:ss\.FFFFFFF') --> 00:00:03.1279569      
Console.WriteLine("Formatting:")
Dim ts1 As TimeSpan = TimeSpan.Parse("0:0:3.6974974")
Console.WriteLine("{0} ('FFFFFFF') --> {0:FFFFFFF}", ts1)

Dim ts2 As TimeSpan = TimeSpan.Parse("0:0:3.9500000")
Console.WriteLine("{0} ('ss\.FFFFFFF') --> {0:ss\.FFFFFFF}", ts2)
Console.WriteLine()

Console.WriteLine("Parsing:")
Dim inputs() As String = { "0:0:03.", "0:0:03.12", "0:0:03.1279569" }
Dim fmt As String = "h\:m\:ss\.FFFFFFF"
Dim ts3 As TimeSpan

For Each input As String In inputs
   If TimeSpan.TryParseExact(input, fmt, Nothing, ts3)
      Console.WriteLine("{0} ('{1}') --> {2}", input, fmt, ts3)
   Else
      Console.WriteLine("Cannot parse {0} with '{1}'.", 
                        input, fmt)
   End If  
Next
' The example displays the following output:
'    Formatting:
'    00:00:03.6974974 ('FFFFFFF') --> 6974974
'    00:00:03.9500000 ('ss\.FFFFFFF') --> 03.95
'    
'    Parsing:
'    0:0:03. ('h\:m\:ss\.FFFFFFF') --> 00:00:03
'    0:0:03.12 ('h\:m\:ss\.FFFFFFF') --> 00:00:03.1200000
'    0:0:03.1279569 ('h\:m\:ss\.FFFFFFF') --> 00:00:03.1279569     

Volver a la tablaBack to table

Otros caracteresOther Characters

Cualquier otro carácter sin escape de una cadena de formato, incluido el carácter de espacio en blanco, se interpreta como especificador de formato personalizado.Any other unescaped character in a format string, including a white-space character, is interpreted as a custom format specifier. En la mayoría de los casos, la presencia de cualquier otro carácter sin escape da lugar a una excepción FormatException.In most cases, the presence of any other unescaped character results in a FormatException.

Para incluir un carácter literal en una cadena de formato, se puede proceder de dos formas:There are two ways to include a literal character in a format string:

  • Se puede escribirlo entre comillas sencillas (delimitador de cadena literal).Enclose it in single quotation marks (the literal string delimiter).

  • Se puede anteponer una barra diagonal inversa ("\"), que se interpreta como un carácter de escape.Precede it with a backslash ("\"), which is interpreted as an escape character. En C#, esto significa que la cadena de formato debe ser @-quoted o que el carácter literal debe ir precedido de una barra diagonal inversa adicional.This means that, in C#, the format string must either be @-quoted, or the literal character must be preceded by an additional backslash.

    En algunos casos, puede que sea necesario usar lógica condicional para incluir un carácter literal de escape en una cadena de formato.In some cases, you may have to use conditional logic to include an escaped literal in a format string. En el ejemplo siguiente se usa lógica condicional para incluir un símbolo de signo para los intervalos de tiempo negativos.The following example uses conditional logic to include a sign symbol for negative time intervals.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          TimeSpan result = new DateTime(2010, 01, 01) - DateTime.Now; 
          String fmt = (result < TimeSpan.Zero ?  "\\-" : "") + "dd\\.hh\\:mm";
          
          Console.WriteLine(result.ToString(fmt));
          Console.WriteLine("Interval: {0:" + fmt + "}", result);
       }
    }
    // The example displays output like the following:
    //       -1291.10:54
    //       Interval: -1291.10:54
    
    Module Example
       Public Sub Main()
          Dim result As TimeSpan = New DateTime(2010, 01, 01) - Date.Now 
          Dim fmt As String = If(result < TimeSpan.Zero, "\-", "") + "dd\.hh\:mm"
          
          Console.WriteLine(result.ToString(fmt))
          Console.WriteLine("Interval: {0:" + fmt + "}", result)
       End Sub
    End Module
    ' The example displays output like the following:
    '       -1291.10:54
    '       Interval: -1291.10:54
    

.NET no define ninguna gramática para los separadores en los intervalos de tiempo..NET does not define a grammar for separators in time intervals. Esto significa que los separadores entre los días y las horas, las horas y los minutos, los minutos y los segundos, y los segundos y las fracciones de segundo deben tratarse todos como literales de carácter en una cadena de formato.This means that the separators between days and hours, hours and minutes, minutes and seconds, and seconds and fractions of a second must all be treated as character literals in a format string.

En el siguiente ejemplo, se utilizan el carácter de escape y la comilla simple para definir una cadena de formato personalizado que incluye la palabra "minutes" en la cadena de salida.The following example uses both the escape character and the single quote to define a custom format string that includes the word "minutes" in the output string.

TimeSpan interval = new TimeSpan(0, 32, 45);
// Escape literal characters in a format string.
string fmt = @"mm\:ss\ \m\i\n\u\t\e\s";
Console.WriteLine(interval.ToString(fmt));
// Delimit literal characters in a format string with the ' symbol.
fmt = "mm':'ss' minutes'";      
Console.WriteLine(interval.ToString(fmt));
// The example displays the following output: 
//       32:45 minutes      
//       32:45 minutes      
Dim interval As New TimeSpan(0, 32, 45)
' Escape literal characters in a format string.
Dim fmt As String = "mm\:ss\ \m\i\n\u\t\e\s"
Console.WriteLine(interval.ToString(fmt))
' Delimit literal characters in a format string with the ' symbol.
fmt = "mm':'ss' minutes'"
Console.WriteLine(interval.ToString(fmt))
' The example displays the following output: 
'       32:45 minutes      
'       32:45 minutes      

Volver a la tablaBack to table

Vea tambiénSee Also

Aplicación de formato a tiposFormatting Types
Cadenas de formato TimeSpan estándarStandard TimeSpan Format Strings