Cadenas de formato TimeSpan estándar

Una cadena de formato estándar TimeSpan usa un único especificador de formato para definir la representación de texto de un valor TimeSpan resultante de una operación de formato. Cualquier cadena de formato que contenga más de un carácter, incluido el espacio en blanco, se interpreta como una cadena de formato TimeSpan personalizado. Para más información, consulte Cadenas de formato TimeSpan personalizadas.

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. Para obtener más información, consulte Aplicar formato a tipos y Formatos compuestos. En el siguiente ejemplo se muestra el uso de cadenas de formato estándar en operaciones de formato.

using System;

public class Example
{
   public static void Main()
   {
      TimeSpan duration = new TimeSpan(1, 12, 23, 62);
      string output = "Time of Travel: " + duration.ToString("c");
      Console.WriteLine(output);

      Console.WriteLine("Time of Travel: {0:c}", duration);
   }
}
// The example displays the following output:
//       Time of Travel: 1.12:24:02
//       Time of Travel: 1.12:24:02
Module Example
    Public Sub Main()
        Dim duration As New TimeSpan(1, 12, 23, 62)
        Dim output As String = "Time of Travel: " + duration.ToString("c")
        Console.WriteLine(output)

        Console.WriteLine("Time of Travel: {0:c}", duration)
    End Sub
End Module
' The example displays the following output:
'       Time of Travel: 1.12:24:02
'       Time of Travel: 1.12:24:02

Los métodos TimeSpan y TimeSpan.ParseExact también usan cadenas de formato TimeSpan.TryParseExact estándar para definir el formato que deben tener las cadenas de entrada de las operaciones de análisis. (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.

using System;

public class Example
{
   public static void Main()
   {
      string value = "1.03:14:56.1667";
      TimeSpan interval;
      try {
         interval = TimeSpan.ParseExact(value, "c", null);
         Console.WriteLine("Converted '{0}' to {1}", value, interval);
      }
      catch (FormatException) {
         Console.WriteLine("{0}: Bad Format", value);
      }
      catch (OverflowException) {
         Console.WriteLine("{0}: Out of Range", value);
      }

      if (TimeSpan.TryParseExact(value, "c", null, out interval))
         Console.WriteLine("Converted '{0}' to {1}", value, interval);
      else
         Console.WriteLine("Unable to convert {0} to a time interval.",
                           value);
   }
}
// The example displays the following output:
//       Converted '1.03:14:56.1667' to 1.03:14:56.1667000
//       Converted '1.03:14:56.1667' to 1.03:14:56.1667000
Module Example
    Public Sub Main()
        Dim value As String = "1.03:14:56.1667"
        Dim interval As TimeSpan
        Try
            interval = TimeSpan.ParseExact(value, "c", Nothing)
            Console.WriteLine("Converted '{0}' to {1}", value, interval)
        Catch e As FormatException
            Console.WriteLine("{0}: Bad Format", value)
        Catch e As OverflowException
            Console.WriteLine("{0}: Out of Range", value)
        End Try

        If TimeSpan.TryParseExact(value, "c", Nothing, interval) Then
            Console.WriteLine("Converted '{0}' to {1}", value, interval)
        Else
            Console.WriteLine("Unable to convert {0} to a time interval.",
                              value)
        End If
    End Sub
End Module
' The example displays the following output:
'       Converted '1.03:14:56.1667' to 1.03:14:56.1667000
'       Converted '1.03:14:56.1667' to 1.03:14:56.1667000

En la tabla siguiente se muestran los especificadores de formato de intervalo de tiempo estándar.

Especificador de formato NOMBRE Descripción Ejemplos
"c" Formato constante (invariable) Este especificador no tiene en cuenta la referencia cultural. Toma la forma [-][d'.']hh':'mm':'ss['.'fffffff].

(Las cadenas de formato "t" y "T" producen los mismos resultados).

Más información: Especificador de formato constante ("c").
TimeSpan.Zero -> 00:00:00

New TimeSpan(0, 0, 30, 0) -> 00:30:00

New TimeSpan(3, 17, 25, 30, 500) -> 3.17:25:30.5000000
"g" Formato corto general Este especificador solo genera lo necesario. Tiene en cuenta la referencia cultural y su forma es [-][d':']h':'mm':'ss[.FFFFFFF].

Más información: Especificador de formato corto general ("g").
New TimeSpan(1, 3, 16, 50, 500) -> 1:3:16:50.5 (en-US)

New TimeSpan(1, 3, 16, 50, 500) -> 1:3:16:50,5 (fr-FR)

New TimeSpan(1, 3, 16, 50, 599) -> 1:3:16:50.599 (en-US)

New TimeSpan(1, 3, 16, 50, 599) -> 1:3:16:50,599 (fr-FR)
"G" Formato general largo Este especificador siempre genera días y siete dígitos fraccionarios. Tiene en cuenta la referencia cultural y su forma es [-]d':'hh':'mm':'ss.fffffff.

Más información: Especificador de formato largo general ("G").
New TimeSpan(18, 30, 0) -> 0:18:30:00.0000000 (en-US)

New TimeSpan(18, 30, 0) -> 0:18:30:00,0000000 (fr-FR)

Especificador de formato constante ("c")

El especificador de formato "c" devuelve la representación de cadena de un valor TimeSpan de la siguiente forma:

[-][d.]hh:mm:ss[.fffffff]

Los elementos de los corchetes ([ y ]) son opcionales. El punto (.) y los dos puntos (:) son símbolos literales. En la siguiente tabla se describen los elementos restantes.

Elemento Descripción
- Signo negativo opcional, que indica un intervalo de tiempo negativo.
d Número opcional de días, sin ceros a la izquierda.
hh Número de horas, entre "00" y "23".
mm Número de minutos, entre "00" y "59".
ss Número de segundos, entre "00" y "59".
fffffff La parte fraccionaria opcional de un segundo. Su valor puede oscilar entre "0000001" (un tic o una diez millonésima de segundo) y "9999999" (9.999.999 diez millonésimas de segundo, o un segundo menos un tic).

A diferencia de los especificadores de formato de "g" y "G", el especificador de formato "c" no tiene en cuenta la referencia cultural. Genera la representación de cadena de un valor TimeSpan que es invariable y común a las versiones anteriores a .NET Framework 4. "c" es la cadena de formato TimeSpan predeterminado; el método TimeSpan.ToString() da formato a un valor de intervalo de tiempo mediante la cadena de formato "c".

Nota

TimeSpan también admite las cadenas de formato estándar "t" y "T", cuyo comportamiento es idéntico al de la cadena de formato estándar "c".

En el ejemplo siguiente se crea una instancia de dos objetos TimeSpan, que se usan para realizar operaciones aritméticas y se muestra el resultado. En cada caso, se utiliza un formato compuesto para mostrar el valor TimeSpan mediante el especificador de formato "c".

using System;

public class Example
{
   public static void Main()
   {
      TimeSpan interval1, interval2;
      interval1 = new TimeSpan(7, 45, 16);
      interval2 = new TimeSpan(18, 12, 38);

      Console.WriteLine("{0:c} - {1:c} = {2:c}", interval1,
                        interval2, interval1 - interval2);
      Console.WriteLine("{0:c} + {1:c} = {2:c}", interval1,
                        interval2, interval1 + interval2);

      interval1 = new TimeSpan(0, 0, 1, 14, 365);
      interval2 = TimeSpan.FromTicks(2143756);
      Console.WriteLine("{0:c} + {1:c} = {2:c}", interval1,
                        interval2, interval1 + interval2);
   }
}
// The example displays the following output:
//       07:45:16 - 18:12:38 = -10:27:22
//       07:45:16 + 18:12:38 = 1.01:57:54
//       00:01:14.3650000 + 00:00:00.2143756 = 00:01:14.5793756
Module Example
    Public Sub Main()
        Dim interval1, interval2 As TimeSpan
        interval1 = New TimeSpan(7, 45, 16)
        interval2 = New TimeSpan(18, 12, 38)

        Console.WriteLine("{0:c} - {1:c} = {2:c}", interval1,
                          interval2, interval1 - interval2)
        Console.WriteLine("{0:c} + {1:c} = {2:c}", interval1,
                          interval2, interval1 + interval2)

        interval1 = New TimeSpan(0, 0, 1, 14, 365)
        interval2 = TimeSpan.FromTicks(2143756)
        Console.WriteLine("{0:c} + {1:c} = {2:c}", interval1,
                          interval2, interval1 + interval2)
    End Sub
End Module
' The example displays the following output:
'       07:45:16 - 18:12:38 = -10:27:22
'       07:45:16 + 18:12:38 = 1.01:57:54
'       00:01:14.3650000 + 00:00:00.2143756 = 00:01:14.5793756

Especificador de formato corto general ("g")

El especificador de formato TimeSpan "g" devuelve la representación de cadena de un valor TimeSpan en una forma compacta, incluyendo únicamente los elementos que sean necesarios. Tiene la forma siguiente:

[-][d:]h:mm:ss[.FFFFFFF]

Los elementos de los corchetes ([ y ]) son opcionales. Los dos puntos (:) son un símbolo literal. En la siguiente tabla se describen los elementos restantes.

Elemento Descripción
- Signo negativo opcional, que indica un intervalo de tiempo negativo.
d Número opcional de días, sin ceros a la izquierda.
h El número de horas, entre "0" a "23", sin ceros a la izquierda.
mm Número de minutos, entre "00" y "59".
ss Número de segundos, entre "00" y "59".
. Separador de fracciones de segundo. Es equivalente a la propiedad NumberDecimalSeparator de la referencia cultural especificada sin invalidaciones del usuario.
FFFFFFF Fracciones de segundo. Se muestra la menor cantidad de dígitos posible.

Al igual que el especificador de formato "G", el especificador de formato "g" se localiza. Su separador de fracciones de segundo se basa en la referencia cultural actual o en la propiedad NumberDecimalSeparator de una referencia cultural especificada.

En el ejemplo siguiente se crea una instancia de dos objetos TimeSpan, que se usan para realizar operaciones aritméticas y se muestra el resultado. En cada caso, se utiliza un formato compuesto para mostrar el valor TimeSpan mediante el especificador de formato "g". Además, se da formato al valor TimeSpan mediante las convenciones de formato de la referencia cultural del sistema actual (que, en este caso, es inglés - Estados Unidos o en-US) y la referencia cultural de Francia de francés (fr-FR).

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      TimeSpan interval1, interval2;
      interval1 = new TimeSpan(7, 45, 16);
      interval2 = new TimeSpan(18, 12, 38);

      Console.WriteLine("{0:g} - {1:g} = {2:g}", interval1,
                        interval2, interval1 - interval2);
      Console.WriteLine(String.Format(new CultureInfo("fr-FR"),
                        "{0:g} + {1:g} = {2:g}", interval1,
                        interval2, interval1 + interval2));

      interval1 = new TimeSpan(0, 0, 1, 14, 36);
      interval2 = TimeSpan.FromTicks(2143756);
      Console.WriteLine("{0:g} + {1:g} = {2:g}", interval1,
                        interval2, interval1 + interval2);
   }
}
// The example displays the following output:
//       7:45:16 - 18:12:38 = -10:27:22
//       7:45:16 + 18:12:38 = 1:1:57:54
//       0:01:14.036 + 0:00:00.2143756 = 0:01:14.2503756
Imports System.Globalization

Module Example
    Public Sub Main()
        Dim interval1, interval2 As TimeSpan
        interval1 = New TimeSpan(7, 45, 16)
        interval2 = New TimeSpan(18, 12, 38)

        Console.WriteLine("{0:g} - {1:g} = {2:g}", interval1,
                          interval2, interval1 - interval2)
        Console.WriteLine(String.Format(New CultureInfo("fr-FR"),
                          "{0:g} + {1:g} = {2:g}", interval1,
                          interval2, interval1 + interval2))

        interval1 = New TimeSpan(0, 0, 1, 14, 36)
        interval2 = TimeSpan.FromTicks(2143756)
        Console.WriteLine("{0:g} + {1:g} = {2:g}", interval1,
                          interval2, interval1 + interval2)
    End Sub
End Module
' The example displays the following output:
'       7:45:16 - 18:12:38 = -10:27:22
'       7:45:16 + 18:12:38 = 1:1:57:54
'       0:01:14.036 + 0:00:00.2143756 = 0:01:14.2503756

Especificador de formato largo general ("G")

El especificador de formato TimeSpan "G" devuelve la representación de cadena de un valor TimeSpan en un formato largo que siempre incluye los días y las fracciones de segundo. La cadena resultante del especificador de formato estándar "G" tiene la forma siguiente:

[-]d:hh:mm:ss.fffffff

Los elementos de los corchetes ([ y ]) son opcionales. Los dos puntos (:) son un símbolo literal. En la siguiente tabla se describen los elementos restantes.

Elemento Descripción
- Signo negativo opcional, que indica un intervalo de tiempo negativo.
d Número de días, sin ceros a la izquierda.
hh Número de horas, entre "00" y "23".
mm Número de minutos, entre "00" y "59".
ss Número de segundos, entre "00" y "59".
. Separador de fracciones de segundo. Es equivalente a la propiedad NumberDecimalSeparator de la referencia cultural especificada sin invalidaciones del usuario.
fffffff Fracciones de segundo.

Al igual que el especificador de formato "G", el especificador de formato "g" se localiza. Su separador de fracciones de segundo se basa en la referencia cultural actual o en la propiedad NumberDecimalSeparator de una referencia cultural especificada.

En el ejemplo siguiente se crea una instancia de dos objetos TimeSpan, que se usan para realizar operaciones aritméticas y se muestra el resultado. En cada caso, se utiliza un formato compuesto para mostrar el valor TimeSpan mediante el especificador de formato "G". Además, se da formato al valor TimeSpan mediante las convenciones de formato de la referencia cultural del sistema actual (que, en este caso, es inglés - Estados Unidos o en-US) y la referencia cultural de Francia de francés (fr-FR).

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      TimeSpan interval1, interval2;
      interval1 = new TimeSpan(7, 45, 16);
      interval2 = new TimeSpan(18, 12, 38);

      Console.WriteLine("{0:G} - {1:G} = {2:G}", interval1,
                        interval2, interval1 - interval2);
      Console.WriteLine(String.Format(new CultureInfo("fr-FR"),
                        "{0:G} + {1:G} = {2:G}", interval1,
                        interval2, interval1 + interval2));

      interval1 = new TimeSpan(0, 0, 1, 14, 36);
      interval2 = TimeSpan.FromTicks(2143756);
      Console.WriteLine("{0:G} + {1:G} = {2:G}", interval1,
                        interval2, interval1 + interval2);
   }
}
// The example displays the following output:
//       0:07:45:16.0000000 - 0:18:12:38.0000000 = -0:10:27:22.0000000
//       0:07:45:16,0000000 + 0:18:12:38,0000000 = 1:01:57:54,0000000
//       0:00:01:14.0360000 + 0:00:00:00.2143756 = 0:00:01:14.2503756
Imports System.Globalization

Module Example
    Public Sub Main()
        Dim interval1, interval2 As TimeSpan
        interval1 = New TimeSpan(7, 45, 16)
        interval2 = New TimeSpan(18, 12, 38)

        Console.WriteLine("{0:G} - {1:G} = {2:G}", interval1,
                          interval2, interval1 - interval2)
        Console.WriteLine(String.Format(New CultureInfo("fr-FR"),
                          "{0:G} + {1:G} = {2:G}", interval1,
                          interval2, interval1 + interval2))

        interval1 = New TimeSpan(0, 0, 1, 14, 36)
        interval2 = TimeSpan.FromTicks(2143756)
        Console.WriteLine("{0:G} + {1:G} = {2:G}", interval1,
                          interval2, interval1 + interval2)
    End Sub
End Module
' The example displays the following output:
'       0:07:45:16.0000000 - 0:18:12:38.0000000 = -0:10:27:22.0000000
'       0:07:45:16,0000000 + 0:18:12:38,0000000 = 1:01:57:54,0000000
'       0:00:01:14.0360000 + 0:00:00:00.2143756 = 0:00:01:14.2503756

Vea también