Cadeias de caracteres de formato TimeSpan personalizadas
A TimeSpan seqüência de caracteres de formato define a representação de seqüência de caracteres de um TimeSpan valor que resulta de uma operação de formatação. Consiste em uma seqüência de caracteres de formato personalizado personalizada de um ou mais TimeSpan especificadores de formato junto com qualquer número de caracteres literal. Qualquer seqüência de caracteres que não é um seqüência de caracteres de formato TimeSpan padrão é interpretado como um personalizado TimeSpan seqüência de caracteres de formato.
.gif "Observação importante") Importante |
|---|
Personalizado TimeSpan especificadores de formato não incluem símbolos de separador de espaço reservado, como, por exemplo, os símbolos que separam os dias a partir de horas, horas, minutos ou segundos desde fracionária de segundos.Em vez disso, esses símbolos devem ser incluídos na seqüência de caracteres de formato personalizado como literais de seqüência de caracteres.Por exemplo, "dd\.hh\:mm" define um ponto (.) como separador entre os dias e horas e dois-pontos (:) como separador entre as horas e minutos. |
As representações de strings de TimeSpan valores são produzidos por chamadas para as sobrecargas da TimeSpan.ToString método e pelos métodos que aceitam formatação composto, tal como String.Format. Para obter mais informações, consulte Tipos de Formatação e Formatação Composta. O exemplo a seguir ilustra o uso de seqüências de caracteres de formato personalizado na formatação de operações.
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
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
Personalizado TimeSpan cadeias de caracteres de formato também são usadas pelo TimeSpan.ParseExact e TimeSpan.TryParseExact métodos para definir o formato obrigatório de seqüências de caracteres de entrada para operações de análise. (Análise converte a representação de seqüência de caracteres de um valor para esse valor.) O exemplo a seguir ilustra o uso de seqüências de caracteres de formato padrão na análise de operações.
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
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
A tabela a seguir descreve os especificadores de formato padrão de data e hora.
Especificador de Formato |
Descrição |
Exemplo |
|---|---|---|
"d", "% d" |
O número de dias inteiros no intervalo de tempo. Mais informações: O "d" O especificador de formato personalizado. |
new TimeSpan(6, 14, 32, 17, 685): %d --> "6" d\.hh\:mm --> "6.14:32" |
"dd"-"dddddddd" |
O número de dias inteiros no intervalo de tempo, preenchido com zeros, conforme necessário. Mais informações: "dd"-"dddddddd" Os especificadores de formato personalizado. |
new TimeSpan(6, 14, 32, 17, 685): ddd --> "006" dd\.hh\:mm --> "06.14:32" |
"h", "% h" |
O número de horas inteiras no intervalo de tempo que não são contados como parte de dias. Horas de dígito único não tem um zero à esquerda. Mais informações: O "h" O especificador de formato personalizado. |
new TimeSpan(6, 14, 32, 17, 685): %h --> "14" hh\:mm --> "14:32" |
"hh" |
O número de horas inteiras no intervalo de tempo que não são contados como parte de dias. Horas de dígito único tem um zero à esquerda. Mais informações: "hh" O especificador de formato personalizado. |
new TimeSpan(6, 14, 32, 17, 685): hh --> "14" new TimeSpan(6, 8, 32, 17, 685): hh --> 08 |
"m", "% m" |
O número de minutos inteiros no intervalo de tempo que não estão incluídos como parte de horas ou dias. Minutos de dígito único não tem um zero à esquerda. Mais informações: "m" O especificador de formato personalizado. |
new TimeSpan(6, 14, 8, 17, 685): %m --> "8" h\:m --> "14:8" |
"mm" |
O número de minutos inteiros no intervalo de tempo que não estão incluídos como parte de horas ou dias. Minutos de dígito único tem um zero à esquerda. Mais informações: "mm" O especificador de formato personalizado. |
new TimeSpan(6, 14, 8, 17, 685): mm --> "08" new TimeSpan(6, 8, 5, 17, 685): d\.hh\:mm\:ss --> 6.08:05:17 |
"s", "% s" |
O número de segundos de todo o intervalo de tempo que não estão incluídos como parte de horas, dias ou minutos. Segundos de dígito único não tem um zero à esquerda. Mais informações: O "s" O especificador de formato personalizado. |
TimeSpan.FromSeconds(12.965): %s --> 12 s\.fff --> 12.965 |
"ss" |
O número de segundos de todo o intervalo de tempo que não estão incluídos como parte de horas, dias ou minutos. Segundos de dígito único tem um zero à esquerda. Mais informações: "ss" O especificador de formato personalizado. |
TimeSpan.FromSeconds(6.965): ss --> 06 ss\.fff --> 06.965 |
"f", "% f" |
Décimos de segundo em um intervalo de tempo. Mais informações: "f" O especificador de formato personalizado. |
TimeSpan.FromSeconds(6.895): f --> 8 ss\.f --> 06.8 |
"ff" |
Centésimos de segundos em um intervalo de tempo. Mais informações: "ff" O especificador de formato personalizado. |
TimeSpan.FromSeconds(6.895): ff --> 89 ss\.ff --> 06.89 |
"fff" |
Milissegundos em um intervalo de tempo. Mais informações: "fff" O especificador de formato personalizado. |
TimeSpan.FromSeconds(6.895): fff --> 895 ss\.fff --> 06.895 |
"ffff" |
Os dez-milésimos de segundo em um intervalo de tempo. Mais informações: "ffff" O especificador de formato personalizado. |
TimeSpan.Parse("0:0:6.8954321"): ffff --> 8954 ss\.ffff --> 06.8954 |
"fffff" |
O cem-milésimos de segundo em um intervalo de tempo. Mais informações: "fffff" O especificador de formato personalizado. |
TimeSpan.Parse("0:0:6.8954321"): fffff --> 89543 ss\.fffff --> 06.89543 |
"ffffff" |
Milionésimos de segundo em um intervalo de tempo. Mais informações: "ffffff" O especificador de formato personalizado. |
TimeSpan.Parse("0:0:6.8954321"): ffffff --> 895432 ss\.ffffff --> 06.895432 |
"fffffff" |
Dez-milionésimos de um segundo (ou os tiques fracionários) em um intervalo de tempo. Mais informações: "fffffff" O especificador de formato personalizado. |
TimeSpan.Parse("0:0:6.8954321"): fffffff --> 8954321 ss\.fffffff --> 06.8954321 |
"F", "% F" |
Décimos de segundo em um intervalo de tempo. Nada será exibido se o dígito for zero. Mais informações: "F" O especificador de formato personalizado. |
TimeSpan.Parse("00:00:06.32"): %F: 3 TimeSpan.Parse("0:0:3.091"): ss\.F: 03. |
"FF" |
Centésimos de segundos em um intervalo de tempo. Qualquer fracionária à direita de zeros ou dois zero dígitos não são incluídos. Mais informações: "FF" O especificador de formato personalizado. |
TimeSpan.Parse("00:00:06.329"): FF: 32 TimeSpan.Parse("0:0:3.101"): ss\.FF: 03.1 |
"FFF" |
Milissegundos em um intervalo de tempo. Zeros à esquerda fracionários não estão incluídos. Mais informações: |
TimeSpan.Parse("00:00:06.3291"): FFF: 329 TimeSpan.Parse("0:0:3.1009"): ss\.FFF: 03.1 |
"FFFF" |
Os dez-milésimos de segundo em um intervalo de tempo. Zeros à esquerda fracionários não estão incluídos. Mais informações: "ffff" O especificador de formato personalizado. |
TimeSpan.Parse("00:00:06.32917"): FFFFF: 3291 TimeSpan.Parse("0:0:3.10009"): ss\.FFFF: 03.1 |
"FFFFF" |
O cem-milésimos de segundo em um intervalo de tempo. Zeros à esquerda fracionários não estão incluídos. Mais informações: "fffff" O especificador de formato personalizado. |
TimeSpan.Parse("00:00:06.329179"): FFFFF: 32917 TimeSpan.Parse("0:0:3.100009"): ss\.FFFFF: 03.1 |
"FFFFFF" |
Milionésimos de segundo em um intervalo de tempo. Fracionários zeros à esquerda não são exibidos. Mais informações: "ffffff" O especificador de formato personalizado. |
TimeSpan.Parse("00:00:06.3291791"): FFFFFF: 329179 TimeSpan.Parse("0:0:3.1000009"): ss\.FFFFFF: 03.1 |
"FFFFFFF" |
Dez - milhões de um segundo em um intervalo de tempo. Zeros à esquerda fracionários ou sete zeros não são exibidos. Mais informações: "fffffff" O especificador de formato personalizado. |
TimeSpan.Parse("00:00:06.3291791"): FFFFFF: 3291791 TimeSpan.Parse("0:0:3.1900000"): ss\.FFFFFF: 03.19 |
' string' |
Delimitador de seqüência de caracteres literal. Mais informações: Outros caracteres. |
new TimeSpan(14, 32, 17): hh':'mm':'ss --> "14:32:17" |
\ |
O caractere de escape. Mais informações: Outros caracteres. |
new TimeSpan(14, 32, 17): hh\:mm\:ss --> "14:32:17" |
Qualquer outro caractere |
Qualquer outro caractere de escape é interpretado como um especificador de formato personalizado. Mais informações: Outros caracteres. |
new TimeSpan(14, 32, 17): hh\:mm\:ss --> "14:32:17" |
O "d" Especificador de formato personalizado
O "d" o especificador de formato personalizado fornece o valor de TimeSpan.Days propriedade, que representa o número de dias inteiros no intervalo de tempo. Ele exibe o número total de dias em um TimeSpan valor, mesmo se o valor tem mais de um dígito. Se o valor de TimeSpan.Days é zero, o especificador de saídas "0".
Se o "d" o especificador de formato personalizado é usado sozinho, especifique "% d" para que ele não é mal interpretado como uma seqüência de caracteres de formato padrão. O exemplo a seguir fornece uma ilustração.
Dim ts As New TimeSpan(16, 4, 3, 17, 250)
Console.WriteLine(ts.ToString("%d"))
' Displays 16
TimeSpan ts1 = new TimeSpan(16, 4, 3, 17, 250);
Console.WriteLine(ts1.ToString("%d"));
// Displays 16
O exemplo a seguir ilustra o uso de "d" especificador de formato personalizado.
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
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
Volta à tabela
"dd"-"dddddddd" Especificadores de formato personalizado
"Dd", "ddd", "dddd", "ddddd", "dddddd", "ddddddd" e "dddddddd" especificadores de formato personalizado a saída do valor de TimeSpan.Days propriedade, que representa o número de dias inteiros no intervalo de tempo.
A seqüência de saída inclui um número mínimo de dígitos especificado pelo número de "d" caracteres de especificador de formato e ele é preenchido com zeros, conforme necessário. Se os dígitos no número de dias excederam o número de "d" caracteres no especificador de formato, o número total de dias é a saída na seqüência de resultado.
O exemplo a seguir usa esses especificadores de formato para exibir a representação de seqüência de caracteres de dois TimeSpan valores. O valor do componente dias do primeiro intervalo de tempo é zero; o valor do componente dias da segunda é 365.
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
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
Volta à tabela
O "h" Especificador de formato personalizado
O "h" especificador de formato personalizado fornece o valor de TimeSpan.Hours propriedade, que representa o número de horas inteiras no intervalo de tempo que não é contabilizada como parte de seu componente do dia. Ele retorna um valor de seqüência de caracteres de um dígito, se o valor da TimeSpan.Hours propriedade é de 0 a 9, e ele retorna um valor de seqüência de caracteres de dois dígitos, se o valor da TimeSpan.Hours varia de propriedade de 10 a 23.
Se o "h" o especificador de formato personalizado é usado sozinho, especifique "% h" para que ele não é mal interpretado como uma seqüência de caracteres de formato padrão. O exemplo a seguir fornece uma ilustração.
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
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
Normalmente, uma operação de análise, uma seqüência de caracteres de entrada que inclui somente um único número será interpretada como o número de dias. Você pode usar o "% h" personalizado Formatar especificador em vez disso, para interpretar a seqüência numérica, como o número de horas. O exemplo a seguir fornece uma ilustração.
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
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
O exemplo a seguir ilustra o uso de "h" especificador de formato personalizado.
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
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
Volta à tabela
"hh" Especificador de formato personalizado
"hh" especificador de formato personalizado fornece o valor de TimeSpan.Hours propriedade, que representa o número de horas inteiras no intervalo de tempo que não é contabilizada como parte de seu componente do dia. Para valores de 0 a 9, a seqüência de caracteres de saída inclui um zero à esquerda.
Normalmente, uma operação de análise, uma seqüência de caracteres de entrada que inclui somente um único número será interpretada como o número de dias. Você pode usar "hh" personalizado Formatar especificador em vez disso, para interpretar a seqüência numérica, como o número de horas. O exemplo a seguir fornece uma ilustração.
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
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
O exemplo a seguir ilustra o uso de "hh" especificador de formato personalizado.
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
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
Volta à tabela
"m" Especificador de formato personalizado
"m" especificador de formato personalizado fornece o valor de TimeSpan.Minutes propriedade, que representa o número de minutos inteiros no intervalo de tempo que não é contabilizada como parte de seu componente do dia. Ele retorna um valor de seqüência de caracteres de um dígito, se o valor da TimeSpan.Minutes propriedade é de 0 a 9, e ele retorna um valor de seqüência de caracteres de dois dígitos, se o valor da TimeSpan.Minutes varia de propriedade de 10 a 59.
Se o "m" o especificador de formato personalizado é usado sozinho, especifique "% m" para que ele não é mal interpretado como uma seqüência de caracteres de formato padrão. O exemplo a seguir fornece uma ilustração.
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
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
Normalmente, uma operação de análise, uma seqüência de caracteres de entrada que inclui somente um único número será interpretada como o número de dias. Você pode usar a "% m" personalizado Formatar especificador em vez disso, para interpretar a seqüência numérica, como o número de minutos. O exemplo a seguir fornece uma ilustração.
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
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
O exemplo a seguir ilustra o uso de "m" especificador de formato personalizado.
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
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
Volta à tabela
"mm" Especificador de formato personalizado
"mm" o especificador de formato personalizado fornece o valor de TimeSpan.Minutes propriedade, que representa o número de minutos inteiros no intervalo de tempo que não é incluído como parte do seu componente horas ou dias. Para valores de 0 a 9, a seqüência de caracteres de saída inclui um zero à esquerda.
Normalmente, uma operação de análise, uma seqüência de caracteres de entrada que inclui somente um único número será interpretada como o número de dias. Você pode usar o "mm" personalizado Formatar especificador em vez disso, para interpretar a seqüência numérica, como o número de minutos. O exemplo a seguir fornece uma ilustração.
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
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
O exemplo a seguir ilustra o uso de "mm" especificador de formato personalizado.
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
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
Volta à tabela
O "s" Especificador de formato personalizado
O "s" o especificador de formato personalizado fornece o valor de TimeSpan.Seconds propriedade, que representa o número de segundos inteiros no intervalo de tempo que não é incluído como parte de suas horas, dias ou componente de minutos. Ele retorna um valor de seqüência de caracteres de um dígito, se o valor da TimeSpan.Seconds propriedade é de 0 a 9, e ele retorna um valor de seqüência de caracteres de dois dígitos, se o valor da TimeSpan.Seconds varia de propriedade de 10 a 59.
Se o "s" o especificador de formato personalizado é usado sozinho, especifique "% s" para que ele não é mal interpretado como uma seqüência de caracteres de formato padrão. O exemplo a seguir fornece uma ilustração.
Dim ts As TimeSpan = TimeSpan.FromSeconds(12.465)
Console.WriteLine(ts.ToString("%s"))
' The example displays the following output:
' 12
TimeSpan ts = TimeSpan.FromSeconds(12.465);
Console.WriteLine(ts.ToString("%s"));
// The example displays the following output:
// 12
Normalmente, uma operação de análise, uma seqüência de caracteres de entrada que inclui somente um único número será interpretada como o número de dias. Você pode usar a "% s" personalizado Formatar especificador em vez disso, para interpretar a seqüência numérica, como o número de segundos. O exemplo a seguir fornece uma ilustração.
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
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
O exemplo a seguir ilustra o uso de "s" especificador de formato personalizado.
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
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
Volta à tabela
"ss" Especificador de formato personalizado
"ss" o especificador de formato personalizado fornece o valor de TimeSpan.Seconds propriedade, que representa o número de segundos inteiros no intervalo de tempo que não é incluído como parte de suas horas, dias ou componente de minutos. Para valores de 0 a 9, a seqüência de caracteres de saída inclui um zero à esquerda.
Normalmente, uma operação de análise, uma seqüência de caracteres de entrada que inclui somente um único número será interpretada como o número de dias. Você pode usar "ss" personalizado Formatar especificador em vez disso, para interpretar a seqüência numérica, como o número de segundos. O exemplo a seguir fornece uma ilustração.
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
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
O exemplo a seguir ilustra o uso de "ss" especificador de formato personalizado.
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
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
Volta à tabela
"f" Especificador de formato personalizado
"f" o especificador de formato personalizado produz os décimos de segundo em um intervalo de tempo. Em uma operação de formatação, os dígitos de fração restantes são truncados. Em uma operação de análise que chama o TimeSpan.ParseExact ou TimeSpan.TryParseExact método, a seqüência de caracteres de entrada deve conter exatamente um dígito fracionária.
Se a letra "f" o especificador de formato personalizado é usado sozinho, especifique "% f" para que ele não é mal interpretado como uma seqüência de caracteres de formato padrão.
O exemplo a seguir usa a letra "f" especificador de formato personalizado para exibir os décimos de segundo em um TimeSpan valor. " f" é usado primeiro como o único especificador de formato e, em seguida, combinado com o "s" especificador de uma seqüência de caracteres de formato personalizado.
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
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
Volta à tabela
"ff" Especificador de formato personalizado
"ff" o especificador de formato personalizado produz os centésimos de segundos em um intervalo de tempo. Em uma operação de formatação, os dígitos de fração restantes são truncados. Em uma operação de análise que chama o TimeSpan.ParseExact ou TimeSpan.TryParseExact método, a seqüência de caracteres de entrada deve conter exatamente dois dígitos fracionais.
O exemplo a seguir usa a "ff" especificador de formato personalizado para exibir os centésimos de segundos em um TimeSpan valor. " FF" é usado primeiro como o único especificador de formato e, em seguida, combinado com o "s" especificador de uma seqüência de caracteres de formato personalizado.
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
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
Volta à tabela
"fff" Especificador de formato personalizado
"fff" especificador de formato personalizado (com três "f" o milissegundos em um intervalo de tempo de entrega de caracteres). Em uma operação de formatação, os dígitos de fração restantes são truncados. Em uma operação de análise que chama o TimeSpan.ParseExact ou TimeSpan.TryParseExact método, a seqüência de caracteres de entrada deve conter exatamente três dígitos fracionais.
O exemplo a seguir utiliza "fff" especificador de formato personalizado para exibir o milissegundos em um TimeSpan valor. " fff" é usado primeiro como o único especificador de formato e, em seguida, combinado com o "s" especificador de uma seqüência de caracteres de formato personalizado.
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
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
Volta à tabela
"ffff" Especificador de formato personalizado
"ffff" especificador de formato personalizado (com quatro "f" caracteres) saídas de dez-milésimos de segundo em um intervalo de tempo. Em uma operação de formatação, os dígitos de fração restantes são truncados. Em uma operação de análise que chama o TimeSpan.ParseExact ou TimeSpan.TryParseExact método, a seqüência de caracteres de entrada deve conter exatamente quatro dígitos fracionais.
O exemplo a seguir utiliza "ffff" especificador de formato personalizado para exibir os dez-milésimos de segundo em um TimeSpan valor. " ffff" é usado primeiro como o único especificador de formato e, em seguida, combinado com o "s" especificador de uma seqüência de caracteres de formato personalizado.
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
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
Volta à tabela
"fffff" Especificador de formato personalizado
"fffff" especificador de formato personalizado (com cinco "f" caracteres) saídas de cem-milésimos de segundo em um intervalo de tempo. Em uma operação de formatação, os dígitos de fração restantes são truncados. Em uma operação de análise que chama o TimeSpan.ParseExact ou TimeSpan.TryParseExact método, a seqüência de caracteres de entrada deve conter exatamente cinco dígitos fracionais.
O exemplo a seguir usa a "fffff" especificador de formato personalizado para exibir o milésimos de centenas de um segundo em um TimeSpan valor. " fffff" é usado primeiro como o único especificador de formato e, em seguida, combinado com o "s" especificador de uma seqüência de caracteres de formato personalizado.
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
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
Volta à tabela
"ffffff" Especificador de formato personalizado
"ffffff" especificador de formato personalizado (com seis "f" os milionésimos de um segundo em um intervalo de tempo de entrega de caracteres). Em uma operação de formatação, os dígitos de fração restantes são truncados. Em uma operação de análise que chama o TimeSpan.ParseExact ou TimeSpan.TryParseExact método, a seqüência de caracteres de entrada deve conter exatamente seis dígitos fracionais.
O exemplo a seguir utiliza "ffffff" especificador de formato personalizado para exibir os milionésimos de um segundo em um TimeSpan valor. Ele é usado primeiro como o único especificador de formato e, em seguida, combinado com o "s" especificador de uma seqüência de caracteres de formato personalizado.
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
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
Volta à tabela
"fffffff" Especificador de formato personalizado
"fffffff" especificador de formato personalizado (com sete "f" caracteres) saídas a milionésimos de dez de um segundo (ou o número fracionário de escalas) em um intervalo de tempo. Em uma operação de análise que chama o TimeSpan.ParseExact ou TimeSpan.TryParseExact método, a seqüência de caracteres de entrada deve conter exatamente sete dígitos fracionais.
O exemplo a seguir usa a "fffffff" especificador de formato personalizado para exibir o número fracionário de pulsos em um TimeSpan valor. Ele é usado primeiro como o único especificador de formato e, em seguida, combinado com o "s" especificador de uma seqüência de caracteres de formato personalizado.
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
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
Volta à tabela
"F" Especificador de formato personalizado
"F" o especificador de formato personalizado produz os décimos de segundo em um intervalo de tempo. Em uma operação de formatação, os dígitos de fração restantes são truncados. Se o valor de décimos do intervalo de tempo de um segundo for zero, ele não está incluído na seqüência de resultado. Em uma operação de análise que chama o TimeSpan.ParseExact ou TimeSpan.TryParseExact método, a presença de décimos de um segundo dígito é opcional.
Se a letra "F" o especificador de formato personalizado é usado sozinho, especifique "% F" para que ele não é mal interpretado como uma seqüência de caracteres de formato padrão.
O exemplo a seguir usa a letra "F" especificador de formato personalizado para exibir os décimos de segundo em um TimeSpan valor. Ele também usa o especificador de formato personalizado em uma operação de análise.
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'.
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'.
Volta à tabela
"FF" Especificador de formato personalizado
"FF" o especificador de formato personalizado produz os centésimos de segundos em um intervalo de tempo. Em uma operação de formatação, os dígitos de fração restantes são truncados. Se houver fracionários zeros à esquerda, não são incluídos na seqüência de resultado. Em uma operação de análise que chama o TimeSpan.ParseExact ou TimeSpan.TryParseExact método, a presença de décimos e centésimos de segundo dígito são opcionais.
O exemplo a seguir usa a "FF" especificador de formato personalizado para exibir os centésimos de segundos em um TimeSpan valor. Ele também usa o especificador de formato personalizado em uma operação de análise.
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'.
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'.
Volta à tabela
"FFF" Especificador de formato personalizado
"FFF" especificador de formato personalizado (com três "F" o milissegundos em um intervalo de tempo de entrega de caracteres). Em uma operação de formatação, os dígitos de fração restantes são truncados. Se houver fracionários zeros à esquerda, não são incluídos na seqüência de resultado. Em uma operação de análise que chama o TimeSpan.ParseExact ou TimeSpan.TryParseExact método, a presença do décimos, centésimos e milésimos de segundo dígito é opcional.
O exemplo a seguir utiliza "FFF" especificador de formato personalizado para exibir os milésimos de segundo em um TimeSpan valor. Ele também usa o especificador de formato personalizado em uma operação de análise.
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'.
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'.
Volta à tabela
"ffff" Especificador de formato personalizado
"ffff" especificador de formato personalizado (com quatro "F" caracteres) saídas de dez-milésimos de segundo em um intervalo de tempo. Em uma operação de formatação, os dígitos de fração restantes são truncados. Se houver fracionários zeros à esquerda, não são incluídos na seqüência de resultado. Em uma operação de análise que chama o TimeSpan.ParseExact ou TimeSpan.TryParseExact método, a presença do décimos, centésimos, milésimos e dez milésimos de segundo dígito é opcional.
O exemplo a seguir utiliza "ffff" especificador de formato personalizado para exibir os dez-milésimos de segundo em um TimeSpan valor. Ele também usa "ffff" especificador de formato personalizado em uma operação de análise.
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'.
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'.
Volta à tabela
"fffff" Especificador de formato personalizado
"fffff" especificador de formato personalizado (com cinco "F" caracteres) saídas de cem-milésimos de segundo em um intervalo de tempo. Em uma operação de formatação, os dígitos de fração restantes são truncados. Se houver fracionários zeros à esquerda, não são incluídos na seqüência de resultado. Em uma operação de análise que chama o TimeSpan.ParseExact ou TimeSpan.TryParseExact método, a presença de décimos, centésimos, milésimos, dez milésimos e milésimos de centenas de um segundo dígito é opcional.
O exemplo a seguir usa a "fffff" especificador de formato personalizado para exibir o milésimos de centenas de um segundo em um TimeSpan valor. Ele também usa "fffff" especificador de formato personalizado em uma operação de análise.
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'.
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'.
Volta à tabela
"ffffff" Especificador de formato personalizado
"ffffff" especificador de formato personalizado (com seis "F" os milionésimos de um segundo em um intervalo de tempo de entrega de caracteres). Em uma operação de formatação, os dígitos de fração restantes são truncados. Se houver fracionários zeros à esquerda, não são incluídos na seqüência de resultado. Em uma operação de análise que chama o TimeSpan.ParseExact ou TimeSpan.TryParseExact método, a presença de décimos, centésimos, milésimos, dez milésimos, milésimos de cem e milionésimos de um segundo dígito é opcional.
O exemplo a seguir utiliza "ffffff" especificador de formato personalizado para exibir os milionésimos de um segundo em um TimeSpan valor. Ele também usa o especificador de formato personalizado em uma operação de análise.
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'.
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'.
Volta à tabela
"fffffff" Especificador de formato personalizado
"fffffff" especificador de formato personalizado (com sete "F" caracteres) saídas a milionésimos de dez de um segundo (ou o número fracionário de escalas) em um intervalo de tempo. Se houver fracionários zeros à esquerda, não são incluídos na seqüência de resultado. Em uma operação de análise que chama o TimeSpan.ParseExact ou TimeSpan.TryParseExact método, a presença de sete dígitos fracionais na seqüência de entrada é opcional.
O exemplo a seguir usa a "fffffff" especificador de formato personalizado para exibir as partes fracionários de um segundo em um TimeSpan valor. Ele também usa o especificador de formato personalizado em uma operação de análise.
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
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
Volta à tabela
Outros caracteres.
Qualquer outro caractere de escape em uma seqüência de caracteres de formato, incluindo um caractere de espaço em branco, é interpretado como um especificador de formato personalizado. Na maioria dos casos, a presença de qualquer outra unescaped resultados de caractere em um FormatException.
Há duas maneiras de incluir um caractere literal em uma seqüência de formato:
Coloque-a entre aspas (o delimitador de seqüência de caracteres literal).
Preceda com barra invertida ("\"), que é interpretado como um caractere de escape. Isso significa que, em C#, a seqüência de caracteres de formato deve ser citado @ ou o caractere literal deve ser precedido por uma barra invertida de adicional.
A.NET Framework não define uma gramática para separadores em intervalos de tempo. Isso significa que os separadores entre os dias e horas, horas e minutos, minutos e segundos e segundos e frações de segundo devem todos ser tratados como literais de caractere em uma seqüência de caracteres de formato.
O exemplo a seguir usa o caractere de escape e a aspa simples para definir uma seqüência de caracteres de formato personalizado que inclui a palavra "minutos" a seqüência de caracteres de saída.
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
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
Volta à tabela