Cadeias de caracteres de formato TimeSpan personalizadoCustom TimeSpan format strings

Uma cadeia de caracteres de formato TimeSpan define a representação de cadeia de caracteres de um valor de TimeSpan que é resultante de uma operação de formatação.A TimeSpan format string defines the string representation of a TimeSpan value that results from a formatting operation. Uma cadeia de caracteres de formato personalizado consiste em um ou mais O especificadores de formato TimeSpan em conjunto com qualquer número de caracteres literais.A custom format string consists of one or more custom TimeSpan format specifiers along with any number of literal characters. Qualquer cadeia de caracteres que não seja uma cadeia de caracteres de formato TimeSpan padrão é interpretada como uma TimeSpan cadeia de formato personalizado.Any string that isn't a Standard TimeSpan format string is interpreted as a custom TimeSpan format string.

Importante

Os especificadores de formato TimeSpan personalizados não incluem símbolos de separador de espaço reservado, como os símbolos que separam dias de horas, horas de minutos ou segundos de frações de segundo.The custom TimeSpan format specifiers don't include placeholder separator symbols, such as the symbols that separate days from hours, hours from minutes, or seconds from fractional seconds. Em vez disso, esses símbolos devem ser incluídos na cadeia de caracteres de formato personalizado como literais de cadeia de caracteres.Instead, these symbols must be included in the custom format string as string literals. Por exemplo, "dd\.hh\:mm" define um ponto (.) como o separador entre dias e horas e dois-pontos (:) como o separador entre horas e 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.

Os especificadores de formato TimeSpan personalizado também não incluem um símbolo de sinal que permite diferenciar entre intervalos de tempo positivos e negativos.Custom TimeSpan format specifiers also don't include a sign symbol that enables you to differentiate between negative and positive time intervals. Para incluir um símbolo de sinal, você precisa construir uma cadeia de caracteres de formato usando lógica condicional.To include a sign symbol, you have to construct a format string by using conditional logic. A seção outros caracteres inclui um exemplo.The Other characters section includes an example.

As representações de sequência de valores TimeSpan são produzidas por chamadas para as sobrecargas do método TimeSpan.ToString e por métodos que oferecem suporte à formatação composta, 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 obter mais informações, consulte Tipos de formatação e Formatação de composição.For more information, see Formatting Types and Composite Formatting. O exemplo a seguir ilustra o uso de sequências de formato personalizado em operações de formatação.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

As sequências de formato TimeSpan personalizado são usadas também pelos métodos TimeSpan.ParseExact e TimeSpan.TryParseExact para definir o formato necessário de sequências de caracteres de entrada para análise de operações.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. (A análise converte a representação de cadeia de caracteres de um valor para esse valor.) O exemplo a seguir ilustra o uso de cadeias de caracteres de formato padrão em operações de análise.(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

A tabela a seguir descreve os especificadores de formato de data e hora personalizados.The following table describes the custom date and time format specifiers.

Especificador de formatoFormat specifier DescriçãoDescription ExemploExample
"d", "%d""d", "%d" O número de dias inteiros no intervalo de tempo.The number of whole days in the time interval.

Mais informações: o 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" O número de dias inteiros no intervalo de tempo, preenchido com zeros à esquerda, conforme necessário.The number of whole days in the time interval, padded with leading zeros as needed.

Mais informações: os 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" O número de horas inteiras no intervalo de tempo que não são contadas como parte dos dias.The number of whole hours in the time interval that aren't counted as part of days. Horas de dígito único não têm um zero à esquerda.Single-digit hours don't have a leading zero.

Mais informações: o 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" O número de horas inteiras no intervalo de tempo que não são contadas como parte dos dias.The number of whole hours in the time interval that aren't counted as part of days. Horas de dígito único têm um zero à esquerda.Single-digit hours have a leading zero.

Mais informações: o 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" O número de minutos inteiros no intervalo de tempo que não são incluídos como parte das horas ou dias.The number of whole minutes in the time interval that aren't included as part of hours or days. Minutos de dígito único não têm um zero à esquerda.Single-digit minutes don't have a leading zero.

Mais informações: o 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" O número de minutos inteiros no intervalo de tempo que não são incluídos como parte das horas ou dias.The number of whole minutes in the time interval that aren't included as part of hours or days. Minutos de dígito único têm um zero à esquerda.Single-digit minutes have a leading zero.

Mais informações: o 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" O número de segundos inteiros no intervalo de tempo que não são incluídos como parte das horas, dias ou minutos.The number of whole seconds in the time interval that aren't included as part of hours, days, or minutes. Segundos de dígito único não têm um zero à esquerda.Single-digit seconds don't have a leading zero.

Mais informações: o 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" O número de segundos inteiros no intervalo de tempo que não são incluídos como parte das horas, dias ou minutos.The number of whole seconds in the time interval that aren't included as part of hours, days, or minutes. Segundos de dígito único têm um zero à esquerda.Single-digit seconds have a leading zero.

Mais informações: o 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" Os décimos de segundo em um intervalo de tempo.The tenths of a second in a time interval.

Mais informações: o 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" Os centésimos de segundo em um intervalo de tempo.The hundredths of a second in a time interval.

Mais informações: o 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" Os milissegundos em um intervalo de tempo.The milliseconds in a time interval.

Mais informações: o 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" Os décimos de milésimos de segundo em um intervalo de tempo.The ten-thousandths of a second in a time interval.

Mais informações: o 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" As centenas de milésimos de segundo em um intervalo de tempo.The hundred-thousandths of a second in a time interval.

Mais informações: o 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" Os milionésimos de segundo em um intervalo de tempo.The millionths of a second in a time interval.

Mais informações: o 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" Os dez milionésimos de segundo (ou as marcas fracionárias) em um intervalo de tempo.The ten-millionths of a second (or the fractional ticks) in a time interval.

Mais informações: o 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" Os décimos de segundo em um intervalo de tempo.The tenths of a second in a time interval. Nada será exibido se o dígito for zero.Nothing is displayed if the digit is zero.

Mais informações: o 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" Os centésimos de segundo em um intervalo de tempo.The hundredths of a second in a time interval. Zeros à direita fracionais ou dois dígitos zero não são incluídos.Any fractional trailing zeros or two zero digits aren't included.

Mais informações: o 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" Os milissegundos em um intervalo de tempo.The milliseconds in a time interval. Zeros à direita fracionais não são incluídos.Any fractional trailing zeros aren't included.

Mais informações: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" Os décimos de milésimos de segundo em um intervalo de tempo.The ten-thousandths of a second in a time interval. Zeros à direita fracionais não são incluídos.Any fractional trailing zeros aren't included.

Mais informações: o 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" As centenas de milésimos de segundo em um intervalo de tempo.The hundred-thousandths of a second in a time interval. Zeros à direita fracionais não são incluídos.Any fractional trailing zeros aren't included.

Mais informações: o 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" Os milionésimos de segundo em um intervalo de tempo.The millionths of a second in a time interval. Zeros à direita fracionais não são exibidos.Any fractional trailing zeros aren't displayed.

Mais informações: o 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" Os décimos de milionésimos de segundo em um intervalo de tempo.The ten-millions of a second in a time interval. Zeros à direita fracionais ou sete dígitos zero não são exibidos.Any fractional trailing zeros or seven zeros aren't displayed.

Mais informações: o 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
'cadeia de caracteres''string' Delimitador de cadeia de caracteres literal.Literal string delimiter.

Mais informações: outros caracteres.More information: Other characters.
new TimeSpan(14, 32, 17):

hh':'mm':'ss --> "14:32:17"hh':'mm':'ss --> "14:32:17"
\\ O caractere de escape.The escape character.

Mais informações: outros caracteres.More information: Other characters.
new TimeSpan(14, 32, 17):

hh\:mm\:ss --> "14:32:17"hh\:mm\:ss --> "14:32:17"
Qualquer outro caractereAny other character Qualquer outro caractere sem escape é interpretado como um especificador de formato personalizado.Any other unescaped character is interpreted as a custom format specifier.

Mais informações: outros caracteres.More Information: Other characters.
new TimeSpan(14, 32, 17):

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

O especificador de formato personalizado "d"The "d" custom format specifier

O especificador de formato personalizado "d" fornece o valor da propriedade TimeSpan.Days, que representa o número de dias inteiros no intervalo de tempo.The "d" custom format specifier outputs the value of the TimeSpan.Days property, which represents the number of whole days in the time interval. Ele gera o número total de dias em um valor de TimeSpan, mesmo se o valor tiver mais de um dígito.It outputs the full number of days in a TimeSpan value, even if the value has more than one digit. Se o valor da propriedade TimeSpan.Days for zero, o especificador gerará "0".If the value of the TimeSpan.Days property is zero, the specifier outputs "0".

Se o especificador de formato personalizado "d" for usado sozinho, especifique "%d" para que ele não seja interpretado incorretamente como uma cadeia de caracteres de formato padrão.If the "d" custom format specifier is used alone, specify "%d" so that it isn't misinterpreted as a standard format string. O exemplo a seguir ilustra esse cenário.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   

O exemplo a seguir ilustra o uso do 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      

Voltar à tabelaBack to table

Os especificadores de formato personalizado "dd"-"dddddddd"The "dd"-"dddddddd" custom format specifiers

Os especificadores de formato personalizados "dd", "ddd", "dddd", "ddddd", "dddddd", "ddddddd" e "dddddddd" fornecem o valor da propriedade TimeSpan.Days, que representa o número de dias inteiros no intervalo de tempo.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.

A cadeia de caracteres de saída inclui um número mínimo de dígitos especificado pelo número de caracteres "d" no especificador de formato e é preenchido com zeros à esquerda conforme necessário.The output string includes a minimum number of digits specified by the number of "d" characters in the format specifier, and it's padded with leading zeros as needed. Se os dígitos do número de dias ultrapassarem o número de caracteres "d" no especificador de formato, o número total de dias será fornecido na cadeia de caracteres de resultado.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.

O exemplo a seguir usa esses O especificadores de formato para exibir a representação de cadeia de caracteres de dois valores de TimeSpan.The following example uses these format specifiers to display the string representation of two TimeSpan values. O valor do componente de dias do primeiro intervalo de tempo é zero; o valor do componente de dias do segundo é 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      

Voltar à tabelaBack to table

O especificador de formato personalizado "h"The "h" custom format specifier

O especificador de formato personalizado "h" fornece o valor da propriedade TimeSpan.Hours, que representa o número de horas inteiras no intervalo de tempo que não são contadas como parte do componente de dia.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 isn't counted as part of its day component. Ele retorna um valor de cadeia de caracteres de um dígito se o valor da propriedade TimeSpan.Hours for de 0 a 9 e retorna um valor de cadeia de caracteres de dois dígitos se o valor da propriedade TimeSpan.Hours for 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.

Se o especificador de formato personalizado "h" for usado sozinho, especifique "%h" para que ele não seja interpretado incorretamente como uma cadeia de caracteres de formato padrão.If the "h" custom format specifier is used alone, specify "%h" so that it isn't misinterpreted as a standard format string. O exemplo a seguir ilustra esse cenário.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, em uma operação de análise, uma cadeia de caracteres de entrada que inclui apenas um único número é interpretada como o número de dias.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Você pode usar o especificador de formato personalizado "%h" em vez disso para interpretar a cadeia de caracteres numérica como o número de horas.You can use the "%h" custom format specifier instead to interpret the numeric string as the number of hours. O exemplo a seguir ilustra esse cenário.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                              

O exemplo a seguir ilustra o uso do 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

Voltar à tabelaBack to table

O especificador de formato personalizado "HH"The "hh" custom format specifier

O especificador de formato personalizado "hh" fornece o valor da propriedade TimeSpan.Hours, que representa o número de horas inteiras no intervalo de tempo que não são contadas como parte do componente de dia.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 isn't counted as part of its day component. Para valores de 0 a 9, a cadeia de caracteres de saída inclui um zero à esquerda.For values from 0 through 9, the output string includes a leading zero.

Normalmente, em uma operação de análise, uma cadeia de caracteres de entrada que inclui apenas um único número é interpretada como o número de dias.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Você pode usar o especificador de formato personalizado "hh" em vez disso para interpretar a cadeia de caracteres numérica como o número de horas.You can use the "hh" custom format specifier instead to interpret the numeric string as the number of hours. O exemplo a seguir ilustra esse cenário.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                              

O exemplo a seguir ilustra o uso do 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

Voltar à tabelaBack to table

O especificador de formato personalizado "m"The "m" custom format specifier

O especificador de formato personalizado "m" fornece o valor da propriedade TimeSpan.Minutes, que representa o número de minutos inteiros no intervalo de tempo que não são contados como parte do componente de dia.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 isn't counted as part of its day component. Ele retorna um valor de cadeia de caracteres de um dígito se o valor da propriedade TimeSpan.Minutes for de 0 a 9 e retorna um valor de cadeia de caracteres de dois dígitos se o valor da propriedade TimeSpan.Minutes for 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.

Se o especificador de formato personalizado "m" for usado sozinho, especifique "%m" para que ele não seja interpretado incorretamente como uma cadeia de caracteres de formato padrão.If the "m" custom format specifier is used alone, specify "%m" so that it isn't misinterpreted as a standard format string. O exemplo a seguir ilustra esse cenário.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, em uma operação de análise, uma cadeia de caracteres de entrada que inclui apenas um único número é interpretada como o número de dias.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Você pode usar o especificador de formato personalizado "%m" em vez disso para interpretar a cadeia de caracteres numérica como o número de minutos.You can use the "%m" custom format specifier instead to interpret the numeric string as the number of minutes. O exemplo a seguir ilustra esse cenário.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                              

O exemplo a seguir ilustra o uso do 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

Voltar à tabelaBack to table

O especificador de formato personalizado "mm"The "mm" custom format specifier

O especificador de formato personalizado "mm" fornece o valor da propriedade TimeSpan.Minutes, que representa o número de minutos inteiros no intervalo de tempo que não está incluído como parte do componente de dia.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 isn't included as part of its hours or days component. Para valores de 0 a 9, a cadeia de caracteres de saída inclui um zero à esquerda.For values from 0 through 9, the output string includes a leading zero.

Normalmente, em uma operação de análise, uma cadeia de caracteres de entrada que inclui apenas um único número é interpretada como o número de dias.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Você pode usar o especificador de formato personalizado "mm" em vez disso para interpretar a cadeia de caracteres numérica como o número de minutos.You can use the "mm" custom format specifier instead to interpret the numeric string as the number of minutes. O exemplo a seguir ilustra esse cenário.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           

O exemplo a seguir ilustra o uso do 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      

Voltar à tabelaBack to table

O especificador de formato personalizado "s"The "s" custom format specifier

O especificador de formato personalizado "s" fornece o valor da propriedade TimeSpan.Seconds, que representa o número de segundos inteiros no intervalo de tempo que não são incluídos como parte do componente de horas, dias ou 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 isn't included as part of its hours, days, or minutes component. Ele retorna um valor de cadeia de caracteres de um dígito se o valor da propriedade TimeSpan.Seconds for de 0 a 9 e retorna um valor de cadeia de caracteres de dois dígitos se o valor da propriedade TimeSpan.Seconds for 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.

Se o especificador de formato personalizado "s" for usado sozinho, especifique "%s" para que ele não seja interpretado incorretamente como uma cadeia de caracteres de formato padrão.If the "s" custom format specifier is used alone, specify "%s" so that it isn't misinterpreted as a standard format string. O exemplo a seguir ilustra esse cenário.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, em uma operação de análise, uma cadeia de caracteres de entrada que inclui apenas um único número é interpretada como o número de dias.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Você pode usar o especificador de formato personalizado "%s" em vez disso para interpretar a cadeia de caracteres numérica como o número de segundos.You can use the "%s" custom format specifier instead to interpret the numeric string as the number of seconds. O exemplo a seguir ilustra esse cenário.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

O exemplo a seguir ilustra o uso do 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      

Voltar à tabelaBack to table

O especificador de formato personalizado "SS"The "ss" custom format specifier

O especificador de formato personalizado "ss" fornece o valor da propriedade TimeSpan.Seconds, que representa o número de segundos inteiros no intervalo de tempo que não são incluídos como parte do componente de horas, dias ou 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 isn't included as part of its hours, days, or minutes component. Para valores de 0 a 9, a cadeia de caracteres de saída inclui um zero à esquerda.For values from 0 through 9, the output string includes a leading zero.

Normalmente, em uma operação de análise, uma cadeia de caracteres de entrada que inclui apenas um único número é interpretada como o número de dias.Ordinarily, in a parsing operation, an input string that includes only a single number is interpreted as the number of days. Você pode usar o especificador de formato personalizado "ss" em vez disso para interpretar a cadeia de caracteres numérica como o número de segundos.You can use the "ss" custom format specifier instead to interpret the numeric string as the number of seconds. O exemplo a seguir ilustra esse cenário.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

O exemplo a seguir ilustra o uso do 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

Voltar à tabelaBack to table

O especificador de formato personalizado "f"The "f" custom format specifier

O especificador de formato personalizado "f" gera os décimos de segundo em um intervalo de tempo.The "f" custom format specifier outputs the tenths of a second in a time interval. Em uma operação de formatação, os dígitos fracionários restantes são truncados.In a formatting operation, any remaining fractional digits are truncated. Em uma operação de análise que chama o método TimeSpan.ParseExact ou TimeSpan.TryParseExact, a cadeia de caracteres de entrada deve conter exatamente um dígitos fracionários.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly one fractional digit.

Se o especificador de formato personalizado "f" for usado sozinho, especifique "%F" para que ele não seja interpretado incorretamente como uma cadeia de caracteres de formato padrão.If the "f" custom format specifier is used alone, specify "%f" so that it isn't misinterpreted as a standard format string.

O exemplo a seguir usa o especificador de formato personalizado "F" para exibir os décimos de segundo em um valor de TimeSpan.The following example uses the "f" custom format specifier to display the tenths of a second in a TimeSpan value. "f" é usado primeiro como o especificador de formato único e, depois, combinado com o especificador "s" em uma cadeia de caracteres 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

Voltar à tabelaBack to table

O especificador de formato personalizado "FF"The "ff" custom format specifier

O especificador de formato personalizado "ff" gera os centésimos de segundo em um intervalo de tempo.The "ff" custom format specifier outputs the hundredths of a second in a time interval. Em uma operação de formatação, os dígitos fracionários restantes são truncados.In a formatting operation, any remaining fractional digits are truncated. Em uma operação de análise que chama o método TimeSpan.ParseExact ou TimeSpan.TryParseExact, a cadeia de caracteres de entrada deve conter exatamente dois dígitos fracionários.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly two fractional digits.

O exemplo a seguir usa o especificador de formato personalizado "FF" para exibir os centésimos de segundo em um valor de TimeSpan.The following example uses the "ff" custom format specifier to display the hundredths of a second in a TimeSpan value. "ff" é usado primeiro como o especificador de formato único e, depois, combinado com o especificador "s" em uma cadeia de caracteres 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

Voltar à tabelaBack to table

O especificador de formato personalizado "fff"The "fff" custom format specifier

O especificador de formato personalizado "fff" (com três caracteres "f") gera os milissegundos em um intervalo de tempo.The "fff" custom format specifier (with three "f" characters) outputs the milliseconds in a time interval. Em uma operação de formatação, os dígitos fracionários restantes são truncados.In a formatting operation, any remaining fractional digits are truncated. Em uma operação de análise que chama o método TimeSpan.ParseExact ou TimeSpan.TryParseExact, a cadeia de caracteres de entrada deve conter exatamente três dígitos fracionários.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly three fractional digits.

O exemplo a seguir usa o especificador de formato personalizado "fff" para exibir os milissegundos em um valor de TimeSpan.The following example uses the "fff" custom format specifier to display the milliseconds in a TimeSpan value. "fff" é usado primeiro como o especificador de formato único e, depois, combinado com o especificador "s" em uma cadeia de caracteres 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

Voltar à tabelaBack to table

O especificador de formato personalizado "ffff"The "ffff" custom format specifier

O especificador de formato personalizado "ffff" (com quatro caracteres "f") gera os décimos de milésimos de segundo em um intervalo de tempo.The "ffff" custom format specifier (with four "f" characters) outputs the ten-thousandths of a second in a time interval. Em uma operação de formatação, os dígitos fracionários restantes são truncados.In a formatting operation, any remaining fractional digits are truncated. Em uma operação de análise que chama o método TimeSpan.ParseExact ou TimeSpan.TryParseExact, a cadeia de caracteres de entrada deve conter exatamente quatro dígitos fracionários.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly four fractional digits.

O exemplo a seguir usa o especificador de formato personalizado "ffff" para exibir os décimos de milésimos de segundo em um valor de TimeSpan.The following example uses the "ffff" custom format specifier to display the ten-thousandths of a second in a TimeSpan value. "ffff" é usado primeiro como o especificador de formato único e, depois, combinado com o especificador "s" em uma cadeia de caracteres 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

Voltar à tabelaBack to table

O especificador de formato personalizado "fffff"The "fffff" custom format specifier

O especificador de formato personalizado "fffff" (com cinco caracteres "f") gera os centésimos de milésimos de segundo em um intervalo de tempo.The "fffff" custom format specifier (with five "f" characters) outputs the hundred-thousandths of a second in a time interval. Em uma operação de formatação, os dígitos fracionários restantes são truncados.In a formatting operation, any remaining fractional digits are truncated. Em uma operação de análise que chama o método TimeSpan.ParseExact ou TimeSpan.TryParseExact, a cadeia de caracteres de entrada deve conter exatamente cinco dígitos fracionários.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly five fractional digits.

O exemplo a seguir usa o especificador de formato personalizado "fffff" para exibir os centésimos de milésimos de segundo em um valor de TimeSpan.The following example uses the "fffff" custom format specifier to display the hundred-thousandths of a second in a TimeSpan value. "fffff" é usado primeiro como o especificador de formato único e, depois, combinado com o especificador "s" em uma cadeia de caracteres 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

Voltar à tabelaBack to table

O especificador de formato personalizado "FFFFFF"The "ffffff" custom format specifier

O especificador de formato personalizado "ffffff" (com seis caracteres "f") gera os milionésimos de segundo em um intervalo de tempo.The "ffffff" custom format specifier (with six "f" characters) outputs the millionths of a second in a time interval. Em uma operação de formatação, os dígitos fracionários restantes são truncados.In a formatting operation, any remaining fractional digits are truncated. Em uma operação de análise que chama o método TimeSpan.ParseExact ou TimeSpan.TryParseExact, a cadeia de caracteres de entrada deve conter exatamente seis dígitos fracionários.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly six fractional digits.

O exemplo a seguir usa o especificador de formato personalizado "ffffff" para exibir os milionésimos de segundo em um valor de TimeSpan.The following example uses the "ffffff" custom format specifier to display the millionths of a second in a TimeSpan value. Ele é usado primeiro como o especificador de formato único e, depois, combinado com o especificador "s" em uma cadeia de caracteres 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

Voltar à tabelaBack to table

O especificador de formato personalizado "fffffff"The "fffffff" custom format specifier

O especificador de formato personalizado "fffffff" (com sete caracteres "f") gera os décimos de milionésimos de segundo (ou o número fracionário de marcadores) em um intervalo de tempo.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. Em uma operação de análise que chama o método TimeSpan.ParseExact ou TimeSpan.TryParseExact, a cadeia de caracteres de entrada deve conter exatamente sete dígitos fracionários.In a parsing operation that calls the TimeSpan.ParseExact or TimeSpan.TryParseExact method, the input string must contain exactly seven fractional digits.

O exemplo a seguir usa o especificador de formato personalizado "fffffff" para exibir o número fracionário de marcadores em um valor de TimeSpan.The following example uses the "fffffff" custom format specifier to display the fractional number of ticks in a TimeSpan value. Ele é usado primeiro como o especificador de formato único e, depois, combinado com o especificador "s" em uma cadeia de caracteres 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

Voltar à tabelaBack to table

O especificador de formato personalizado "F"The "F" custom format specifier

O especificador de formato personalizado "F" gera os décimos de segundo em um intervalo de tempo.The "F" custom format specifier outputs the tenths of a second in a time interval. Em uma operação de formatação, os dígitos fracionários restantes são truncados.In a formatting operation, any remaining fractional digits are truncated. Se o valor dos décimos de segundo do intervalo de tempo for zero, ele não será incluído na cadeia de caracteres de resultado.If the value of the time interval's tenths of a second is zero, it isn't included in the result string. Em uma operação de análise que chama o método TimeSpan.ParseExact ou TimeSpan.TryParseExact, a presença de décimos de um segundo dígito é 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.

Se o especificador de formato personalizado "F" for usado sozinho, especifique "%F" para que ele não seja interpretado incorretamente como uma cadeia de caracteres de formato padrão.If the "F" custom format specifier is used alone, specify "%F" so that it isn't misinterpreted as a standard format string.

O exemplo a seguir usa o especificador de formato personalizado "F" para exibir os décimos de segundo em um valor de TimeSpan.The following example uses the "F" custom format specifier to display the tenths of a second in a TimeSpan value. Ele também usa este especificador de formato personalizado em uma operação de análise.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'.      

Voltar à tabelaBack to table

O especificador de formato personalizado "FF"The "FF" custom format specifier

O especificador de formato personalizado "FF" gera os centésimos de segundo em um intervalo de tempo.The "FF" custom format specifier outputs the hundredths of a second in a time interval. Em uma operação de formatação, os dígitos fracionários restantes são truncados.In a formatting operation, any remaining fractional digits are truncated. Se houver zeros fracionários à direita, eles não serão incluídos na cadeia de caracteres de resultado.If there are any trailing fractional zeros, they aren't included in the result string. Em uma operação de análise que chama o método TimeSpan.ParseExact ou TimeSpan.TryParseExact, a presença de décimos e centésimos de um segundo dígito é 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.

O exemplo a seguir usa o especificador de formato personalizado "FF" para exibir os centésimos de segundo em um valor de TimeSpan.The following example uses the "FF" custom format specifier to display the hundredths of a second in a TimeSpan value. Ele também usa este especificador de formato personalizado em uma operação de análise.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'.

Voltar à tabelaBack to table

O especificador de formato personalizado "FFF"The "FFF" custom format specifier

O especificador de formato personalizado "FFF" (com três caracteres "F") gera os milissegundos em um intervalo de tempo.The "FFF" custom format specifier (with three "F" characters) outputs the milliseconds in a time interval. Em uma operação de formatação, os dígitos fracionários restantes são truncados.In a formatting operation, any remaining fractional digits are truncated. Se houver zeros fracionários à direita, eles não serão incluídos na cadeia de caracteres de resultado.If there are any trailing fractional zeros, they aren't included in the result string. Em uma operação de análise que chama o método TimeSpan.ParseExact ou TimeSpan.TryParseExact, a presença do dígito de décimos, centésimos e milésimos de segundo é 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.

O exemplo a seguir usa o especificador de formato personalizado "FFF" para exibir os milésimos de segundo em um valor de TimeSpan.The following example uses the "FFF" custom format specifier to display the thousandths of a second in a TimeSpan value. Ele também usa este especificador de formato personalizado em uma operação de análise.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'.

Voltar à tabelaBack to table

O especificador de formato personalizado "FFFF"The "FFFF" custom format specifier

O especificador de formato personalizado "FFFF" (com quatro caracteres "f") gera os décimos de milésimos de segundo em um intervalo de tempo.The "FFFF" custom format specifier (with four "F" characters) outputs the ten-thousandths of a second in a time interval. Em uma operação de formatação, os dígitos fracionários restantes são truncados.In a formatting operation, any remaining fractional digits are truncated. Se houver zeros fracionários à direita, eles não serão incluídos na cadeia de caracteres de resultado.If there are any trailing fractional zeros, they aren't included in the result string. Em uma operação de análise que chama o método TimeSpan.ParseExact ou TimeSpan.TryParseExact, a presença do dígito de décimos, centésimos, milésimos e décimos de milésimos de segundo é 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.

O exemplo a seguir usa o especificador de formato personalizado "FFFF" para exibir os décimos de milésimos de segundo em um valor de TimeSpan.The following example uses the "FFFF" custom format specifier to display the ten-thousandths of a second in a TimeSpan value. Ele também usa o especificador de formato personalizado "FFFF" em uma operação de análise.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'.

Voltar à tabelaBack to table

O especificador de formato personalizado "FFFFF"The "FFFFF" custom format specifier

O especificador de formato personalizado "FFFFF" (com cinco caracteres "F") gera os centésimos de milésimos de segundo em um intervalo de tempo.The "FFFFF" custom format specifier (with five "F" characters) outputs the hundred-thousandths of a second in a time interval. Em uma operação de formatação, os dígitos fracionários restantes são truncados.In a formatting operation, any remaining fractional digits are truncated. Se houver zeros fracionários à direita, eles não serão incluídos na cadeia de caracteres de resultado.If there are any trailing fractional zeros, they aren't included in the result string. Em uma operação de análise que chama o método TimeSpan.ParseExact ou TimeSpan.TryParseExact, a presença do dígito de décimos, centésimos, milésimos e décimos de milésimos e centésimos de milésimos de segundo é 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.

O exemplo a seguir usa o especificador de formato personalizado "FFFFF" para exibir os centésimos de milésimos de segundo em um valor de TimeSpan.The following example uses the "FFFFF" custom format specifier to display the hundred-thousandths of a second in a TimeSpan value. Ele também usa o especificador de formato personalizado "FFFFF" em uma operação de análise.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'.

Voltar à tabelaBack to table

O especificador de formato personalizado "FFFFFF"The "FFFFFF" custom format specifier

O especificador de formato personalizado "FFFFFF" (com seis caracteres "F") gera os milionésimos de segundo em um intervalo de tempo.The "FFFFFF" custom format specifier (with six "F" characters) outputs the millionths of a second in a time interval. Em uma operação de formatação, os dígitos fracionários restantes são truncados.In a formatting operation, any remaining fractional digits are truncated. Se houver zeros fracionários à direita, eles não serão incluídos na cadeia de caracteres de resultado.If there are any trailing fractional zeros, they aren't included in the result string. Em uma operação de análise que chama o método TimeSpan.ParseExact ou TimeSpan.TryParseExact, a presença do dígito de décimos, centésimos, milésimos, décimos de milésimos, centésimos de milésimos e milionésimos de segundo é 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.

O exemplo a seguir usa o especificador de formato personalizado "FFFFFF" para exibir os milionésimos de segundo em um valor de TimeSpan.The following example uses the "FFFFFF" custom format specifier to display the millionths of a second in a TimeSpan value. Ele também usa este especificador de formato personalizado em uma operação de análise.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'.

Voltar à tabelaBack to table

O especificador de formato personalizado "FFFFFFF"The "FFFFFFF" custom format specifier

O especificador de formato personalizado "FFFFFFF" (com sete caracteres "F") gera os décimos de milionésimos de segundo (ou o número fracionário de marcadores) em um intervalo de tempo.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. Se houver zeros fracionários à direita, eles não serão incluídos na cadeia de caracteres de resultado.If there are any trailing fractional zeros, they aren't included in the result string. Em uma operação de análise que chama o método TimeSpan.ParseExact ou TimeSpan.TryParseExact, a presença dos sete dígitos fracionários na cadeia de entrada é 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.

O exemplo a seguir usa o especificador de formato personalizado "FFFFFFF" para exibir as partes fracionárias de um segundo em um valor de TimeSpan.The following example uses the "FFFFFFF" custom format specifier to display the fractional parts of a second in a TimeSpan value. Ele também usa este especificador de formato personalizado em uma operação de análise.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     

Voltar à tabelaBack to table

Outros caracteresOther characters

Qualquer outro caractere sem escape em uma cadeia de caracteres de formato, incluindo um caractere de espaço em branco, é interpretado como um especificador de formato personalizado.Any other unescaped character in a format string, including a white-space character, is interpreted as a custom format specifier. Na maioria dos casos, a presença de qualquer outro caractere sem escape resulta em uma FormatException.In most cases, the presence of any other unescaped character results in a FormatException.

Há duas maneiras de incluir um caractere literal em uma cadeia de caracteres de formato:There are two ways to include a literal character in a format string:

  • Coloque-o entre aspas simples (o delimitador de cadeia de caracteres literal).Enclose it in single quotation marks (the literal string delimiter).

  • Preceda-o com uma barra invertida ("\"), que é interpretada como um caractere de escape.Precede it with a backslash ("\"), which is interpreted as an escape character. Isso significa que, em C#, a cadeia de caracteres de formato deve demarcado por @-quoted, ou o caractere literal deve ser precedido por uma barra invertida adicional.This means that, in C#, the format string must either be @-quoted, or the literal character must be preceded by an additional backslash.

    Em alguns casos, talvez você precise usar lógica condicional para incluir um literal de escape em uma cadeia de caracteres de formato.In some cases, you may have to use conditional logic to include an escaped literal in a format string. O exemplo a seguir usa lógica condicional para incluir um símbolo de sinal para intervalos de tempo 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
    

O .NET não define uma gramática para separadores em intervalos de tempo..NET doesn't define a grammar for separators in time intervals. Isso significa que os separadores entre dias e horas, horas e minutos, minutos e segundos, e segundos e frações de segundo devem ser tratados como literais de caracteres em uma cadeia de caracteres 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.

O exemplo a seguir usa o caractere de escape e a aspa simples para definir uma cadeia de caracteres de formato personalizado que inclui a palavra "minutos" na cadeia de caracteres de saída.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      

Voltar à tabelaBack to table

Veja tambémSee also