Cadeias de formato TimeSpan personalizadas
Uma TimeSpan cadeia de formato define a representação da cadeia de carateres de um TimeSpan valor que resulta de uma operação de formatação. Uma cadeia de formato personalizado consiste num ou mais especificadores de formato personalizado TimeSpan , juntamente com qualquer número de carateres literais. Qualquer cadeia que não seja uma cadeia de formato TimeSpan Padrão é interpretada como uma cadeia de formato personalizado TimeSpan .
Importante
Os especificadores de formato personalizado TimeSpan não incluem símbolos de separador de marcador de posição, tais como os símbolos que separam dias de horas, horas de minutos ou segundos de segundos fracionários. Em vez disso, estes símbolos têm de ser incluídos na cadeia de formato personalizado como literais de cadeia. Por exemplo, "dd\.hh\:mm" define um ponto final (.) como o separador entre dias e horas e dois pontos (:) como separador entre horas e minutos.
Os especificadores de formato personalizado TimeSpan também não incluem um símbolo de sinal que lhe permita diferenciar entre intervalos de tempo negativos e positivos. Para incluir um símbolo de sinal, tem de construir uma cadeia de formato através da lógica condicional. A secção Outros carateres inclui um exemplo.
As representações de cadeias de TimeSpan valores são produzidas por chamadas para as sobrecargas do TimeSpan.ToString método e por métodos que suportam a formatação composta, como String.Format. Para obter mais informações, veja Formatting Types and Composite Formatting (Tipos de Formatação e Formatação Composta). O exemplo seguinte ilustra a utilização de cadeias de formato personalizadas em operações de formatação.
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 cadeias de formato personalizado TimeSpan também são utilizadas pelos TimeSpan.ParseExact métodos e TimeSpan.TryParseExact para definir o formato necessário das cadeias de entrada para operações de análise. (A análise converte a representação da cadeia de carateres de um valor nesse valor.) O exemplo seguinte ilustra a utilização de cadeias de formato padrão nas operações de análise.
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 seguinte descreve os especificadores de formatos de data e hora personalizados.
| Especificador de formato | Descrição | Exemplo |
|---|---|---|
| "d", "%d" | O número de dias inteiros no intervalo de tempo. Mais informações: o especificador de formato personalizado "d". |
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, acolchoado com zeros à esquerda, conforme necessário. Mais informações: os especificadores de formato personalizado "dd"-"ddddddddd". |
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 contadas como parte dos dias. As horas de um dígito não têm um zero à esquerda. Mais informações: o especificador de formato personalizado "h". |
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 contadas como parte dos dias. As horas de um dígito têm um zero à esquerda. Mais informações: o especificador de formato personalizado "hh". |
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. Os minutos de um dígito não têm um zero à esquerda. Mais informações: o especificador de formato personalizado "m". |
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. Os minutos de um dígito têm um zero à esquerda. Mais informações: o especificador de formato personalizado "mm". |
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 inteiros no intervalo de tempo que não estão incluídos como parte de horas, dias ou minutos. Os segundos de um dígito não têm um zero à esquerda. Mais informações: o especificador de formato personalizado "s". |
TimeSpan.FromSeconds(12.965):%s --> 12s\.fff --> 12.965 |
| "ss" | O número de segundos inteiros no intervalo de tempo que não estão incluídos como parte de horas, dias ou minutos. Os segundos de um dígito têm um zero à esquerda. Mais informações: o especificador de formato personalizado "ss". |
TimeSpan.FromSeconds(6.965):ss --> 06ss\.fff --> 06.965 |
| "f", "%f" | Os décimos de segundo num intervalo de tempo. Mais informações: o especificador de formato personalizado "f". |
TimeSpan.FromSeconds(6.895):f --> 8ss\.f --> 06.8 |
| "ff" | Os centésimos de segundo num intervalo de tempo. Mais informações: o especificador de formato personalizado "ff". |
TimeSpan.FromSeconds(6.895):ff --> 89ss\.ff --> 06.89 |
| "fff" | Os milissegundos num intervalo de tempo. Mais informações: o especificador de formato personalizado "fff". |
TimeSpan.FromSeconds(6.895):fff --> 895ss\.fff --> 06.895 |
| "ffff" | Os dez milésimos de segundo num intervalo de tempo. Mais informações: o especificador de formato personalizado "ffff". |
TimeSpan.Parse("0:0:6.8954321"):ffff --> 8954ss\.ffff --> 06.8954 |
| "fffff" | Os centésimos milésimos de segundo num intervalo de tempo. Mais informações: o especificador de formato personalizado "fffff". |
TimeSpan.Parse("0:0:6.8954321"):fffff --> 89543ss\.fffff --> 06.89543 |
| "ffffff" | Os milionésimos de segundo num intervalo de tempo. Mais informações: o especificador de formato personalizado "ffffff". |
TimeSpan.Parse("0:0:6.8954321"):ffffff>- 895432ss\.ffffff --> 06.895432 |
| "fffffff" | Os dez milionésimos de segundo (ou os tiques fracionários) num intervalo de tempo. Mais informações: O especificador de formato personalizado "fffffff". |
TimeSpan.Parse("0:0:6.8954321"):fffffff --> 8954321ss\.fffffff --> 06.8954321 |
| "F", "%F" | Os décimos de segundo num intervalo de tempo. Nada é apresentado se o dígito for zero. Mais informações: O especificador de formato personalizado "F". |
TimeSpan.Parse("00:00:06.32"):%F: 3TimeSpan.Parse("0:0:3.091"):ss\.F: 03. |
| "FF" | Os centésimos de segundo num intervalo de tempo. Não são incluídos quaisquer zeros fracionários ou dois dígitos zero. Mais informações: O especificador de formato personalizado "FF". |
TimeSpan.Parse("00:00:06.329"):FF: 32TimeSpan.Parse("0:0:3.101"):ss\.FF: 03.1 |
| "FFF" | Os milissegundos num intervalo de tempo. Não são incluídos quaisquer zeros fracionários à direita. Mais Informações: |
TimeSpan.Parse("00:00:06.3291"):FFF: 329TimeSpan.Parse("0:0:3.1009"):ss\.FFF: 03.1 |
| "FFFF" | Os dez milésimos de segundo num intervalo de tempo. Não são incluídos quaisquer zeros fracionários à direita. Mais informações: O especificador de formato personalizado "FFFF". |
TimeSpan.Parse("00:00:06.32917"):FFFFF: 3291TimeSpan.Parse("0:0:3.10009"):ss\.FFFF: 03.1 |
| "FFFFF" | Os centésimos milésimos de segundo num intervalo de tempo. Não são incluídos quaisquer zeros fracionários à direita. Mais informações: O especificador de formato personalizado "FFFFF". |
TimeSpan.Parse("00:00:06.329179"):FFFFF: 32917TimeSpan.Parse("0:0:3.100009"):ss\.FFFFF: 03.1 |
| "FFFFFF" | Os milionésimos de segundo num intervalo de tempo. Não são apresentados quaisquer zeros fracionários à direita. Mais informações: O especificador de formato personalizado "FFFFFF". |
TimeSpan.Parse("00:00:06.3291791"):FFFFFF: 329179TimeSpan.Parse("0:0:3.1000009"):ss\.FFFFFF: 03.1 |
| "FFFFFFF" | Os 10 milhões de segundo num intervalo de tempo. Não são apresentados zeros ou sete zeros fracionários à direita. Mais informações: O especificador de formato personalizado "FFFFFFF". |
TimeSpan.Parse("00:00:06.3291791"):FFFFFF: 3291791TimeSpan.Parse("0:0:3.1900000"):ss\.FFFFFF: 03.19 |
| "cadeia" | Delimitador de cadeias literais. Mais informações: Outros carateres. |
new TimeSpan(14, 32, 17):hh':'mm':'ss --> "14:32:17" |
| \ | O caráter de fuga. Mais informações: Outros carateres. |
new TimeSpan(14, 32, 17):hh\:mm\:ss --> "14:32:17" |
| Qualquer outro caráter | Qualquer outro caráter não paisagens é interpretado como um especificador de formato personalizado. Mais Informações: Outros carateres. |
new TimeSpan(14, 32, 17):hh\:mm\:ss --> "14:32:17" |
O especificador de formato personalizado "d"
O especificador de formato personalizado "d" produz o valor da TimeSpan.Days propriedade, que representa o número de dias inteiros no intervalo de tempo. Produz o número total de dias num TimeSpan valor, mesmo que o valor tenha mais de um dígito. Se o valor da TimeSpan.Days propriedade for zero, o especificador produz "0".
Se o especificador de formato personalizado "d" for utilizado individualmente, especifique "%d" para que não seja mal interpretado como uma cadeia de formato padrão. O exemplo seguinte fornece uma ilustração.
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 seguinte ilustra a utilização do especificador de formato personalizado "d".
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
Os especificadores de formato personalizado "dd"-"ddddddd"
Os especificadores de formato personalizado "ddd", "dddd", "ddddd", "dddddd", "ddddddd" e "ddddddd" produzem o valor da TimeSpan.Days propriedade, que representa o número de dias inteiros no intervalo de tempo.
A cadeia de saída inclui um número mínimo de dígitos especificado pelo número de carateres "d" no especificador de formato e é acolchoada com zeros à esquerda, conforme necessário. Se os dígitos no número de dias excederem o número de carateres "d" no especificador de formato, o número total de dias será apresentado na cadeia de resultados.
O exemplo seguinte utiliza estes especificadores de formato para apresentar a representação de cadeia de carateres de dois TimeSpan valores. O valor do componente days do primeiro intervalo de tempo é zero; o valor do componente days do segundo é 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
O especificador de formato personalizado "h"
O especificador de formato personalizado "h" produz o valor da TimeSpan.Hours propriedade, que representa o número de horas inteiras no intervalo de tempo que não é contado como parte do componente do dia. Devolve um valor de cadeia de um dígito se o valor da TimeSpan.Hours propriedade for de 0 a 9 e devolver um valor de cadeia de dois dígitos se o valor da TimeSpan.Hours propriedade variar entre 10 e 23.
Se o especificador de formato personalizado "h" for utilizado individualmente, especifique "%h" para que não seja mal interpretado como uma cadeia de formato padrão. O exemplo seguinte fornece uma ilustração.
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, numa operação de análise, uma cadeia de entrada que inclui apenas um único número é interpretada como o número de dias. Em vez disso, pode utilizar o especificador de formato personalizado "%h" para interpretar a cadeia numérica como o número de horas. O exemplo seguinte fornece uma ilustração.
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 seguinte ilustra a utilização do especificador de formato personalizado "h".
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
O especificador de formato personalizado "hh"
O especificador de formato personalizado "hh" produz o valor da TimeSpan.Hours propriedade, que representa o número de horas inteiras no intervalo de tempo que não é contado como parte do componente do dia. Para valores de 0 a 9, a cadeia de saída inclui um zero à esquerda.
Normalmente, numa operação de análise, uma cadeia de entrada que inclui apenas um único número é interpretada como o número de dias. Em vez disso, pode utilizar o especificador de formato personalizado "hh" para interpretar a cadeia numérica como o número de horas. O exemplo seguinte fornece uma ilustração.
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 seguinte ilustra a utilização do especificador de formato personalizado "hh".
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
O especificador de formato personalizado "m"
O especificador de formato personalizado "m" produz o valor da TimeSpan.Minutes propriedade, que representa o número de minutos inteiros no intervalo de tempo que não é contado como parte do componente day. Devolve um valor de cadeia de um dígito se o valor da TimeSpan.Minutes propriedade for de 0 a 9 e devolver um valor de cadeia de dois dígitos se o valor da TimeSpan.Minutes propriedade variar entre 10 e 59.
Se o especificador de formato personalizado "m" for utilizado individualmente, especifique "%m" para que não seja mal interpretado como uma cadeia de formato padrão. O exemplo seguinte fornece uma ilustração.
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, numa operação de análise, uma cadeia de entrada que inclui apenas um único número é interpretada como o número de dias. Em vez disso, pode utilizar o especificador de formato personalizado "%m" para interpretar a cadeia numérica como o número de minutos. O exemplo seguinte fornece uma ilustração.
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 seguinte ilustra a utilização do especificador de formato personalizado "m".
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
O especificador de formato personalizado "mm"
O especificador de formato personalizado "mm" produz o valor da TimeSpan.Minutes propriedade, que representa o número de minutos inteiros no intervalo de tempo que não está incluído como parte do componente de horas ou dias. Para valores de 0 a 9, a cadeia de saída inclui um zero à esquerda.
Normalmente, numa operação de análise, uma cadeia de entrada que inclua apenas um único número é interpretada como o número de dias. Em vez disso, pode utilizar o especificador de formato personalizado "mm" para interpretar a cadeia numérica como o número de minutos. O exemplo seguinte fornece uma ilustração.
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 seguinte ilustra a utilização do especificador de formato personalizado "mm".
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
O especificador de formato personalizado "s"
O especificador de formato personalizado "s" produz o valor da TimeSpan.Seconds propriedade, que representa o número de segundos inteiros no intervalo de tempo que não está incluído como parte do componente horas, dias ou minutos. Devolve um valor de cadeia de um dígito se o valor da TimeSpan.Seconds propriedade for 0 a 9 e devolver um valor de cadeia de dois dígitos se o valor da TimeSpan.Seconds propriedade variar entre 10 e 59.
Se o especificador de formato personalizado "s" for utilizado apenas, especifique "%s" para que não seja mal interpretado como uma cadeia de formato padrão. O exemplo seguinte fornece uma ilustração.
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, numa operação de análise, uma cadeia de entrada que inclua apenas um único número é interpretada como o número de dias. Em vez disso, pode utilizar o especificador de formato personalizado "%s" para interpretar a cadeia numérica como o número de segundos. O exemplo seguinte fornece uma ilustração.
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 seguinte ilustra a utilização do especificador de formato personalizado "s".
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
O especificador de formato personalizado "ss"
O especificador de formato personalizado "ss" produz o valor da TimeSpan.Seconds propriedade, que representa o número de segundos inteiros no intervalo de tempo que não está incluído como parte do componente horas, dias ou minutos. Para valores de 0 a 9, a cadeia de saída inclui um zero à esquerda.
Normalmente, numa operação de análise, uma cadeia de entrada que inclua apenas um único número é interpretada como o número de dias. Em vez disso, pode utilizar o especificador de formato personalizado "ss" para interpretar a cadeia numérica como o número de segundos. O exemplo seguinte fornece uma ilustração.
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 seguinte ilustra a utilização do especificador de formato personalizado "ss".
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
O especificador de formato personalizado "f"
O especificador de formato personalizado "f" produz as décimas de um segundo num intervalo de tempo. Numa operação de formatação, os dígitos fracionários restantes são truncados. Numa operação de análise que chama o TimeSpan.ParseExact método ou TimeSpan.TryParseExact , a cadeia de entrada tem de conter exatamente um dígito fracionário.
Se o especificador de formato personalizado "f" for utilizado sozinho, especifique "%f" para que não seja mal interpretado como uma cadeia de formato padrão.
O exemplo seguinte utiliza o especificador de formato personalizado "f" para apresentar as décimas de um segundo num TimeSpan valor. "f" é utilizado primeiro como o único especificador de formato e, em seguida, combinado com o especificador "s" numa cadeia de formato personalizado.
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
O especificador de formato personalizado "ff"
O especificador de formato personalizado "ff" produz as centésimos de segundo num intervalo de tempo. Numa operação de formatação, os dígitos fracionários restantes são truncados. Numa operação de análise que chama o TimeSpan.ParseExact método ou TimeSpan.TryParseExact , a cadeia de entrada tem de conter exatamente dois dígitos fracionários.
O exemplo seguinte utiliza o especificador de formato personalizado "ff" para apresentar as centésimos de segundo num TimeSpan valor. "ff" é utilizado primeiro como o único especificador de formato e, em seguida, combinado com o especificador "s" numa cadeia de formato personalizado.
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
O especificador de formato personalizado "fff"
O especificador de formato personalizado "fff" (com três carateres "f") produz os milissegundos num intervalo de tempo. Numa operação de formatação, os dígitos fracionários restantes são truncados. Numa operação de análise que chama o TimeSpan.ParseExact método ou TimeSpan.TryParseExact , a cadeia de entrada tem de conter exatamente três dígitos fracionários.
O exemplo seguinte utiliza o especificador de formato personalizado "fff" para apresentar os milissegundos num TimeSpan valor. "fff" é utilizado primeiro como o único especificador de formato e, em seguida, combinado com o especificador "s" numa cadeia de formato personalizado.
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
O especificador de formato personalizado "ffff"
O especificador de formato personalizado "ffff" (com quatro carateres "f") produz os dez milésimos de segundo num intervalo de tempo. Numa operação de formatação, os dígitos fracionários restantes são truncados. Numa operação de análise que chama o TimeSpan.ParseExact método ou TimeSpan.TryParseExact , a cadeia de entrada tem de conter exatamente quatro dígitos fracionários.
O exemplo seguinte utiliza o especificador de formato personalizado "ffff" para apresentar os dez milésimos de segundo num TimeSpan valor. "ffff" é utilizado primeiro como o único especificador de formato e, em seguida, combinado com o especificador "s" numa cadeia de formato personalizado.
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
O especificador de formato personalizado "fffff"
O especificador de formato personalizado "fffff" (com cinco carateres "f") produz os centésimos milésimos de segundo num intervalo de tempo. Numa operação de formatação, os dígitos fracionários restantes são truncados. Numa operação de análise que chama o TimeSpan.ParseExact método ou TimeSpan.TryParseExact , a cadeia de entrada tem de conter exatamente cinco dígitos fracionários.
O exemplo seguinte utiliza o especificador de formato personalizado "fffff" para apresentar as centenas de milésimos de segundo num TimeSpan valor. "fffff" é utilizado primeiro como o único especificador de formato e, em seguida, combinado com o especificador "s" numa cadeia de formato personalizado.
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
O especificador de formato personalizado "ffffff"
O especificador de formato personalizado "ffffff" (com seis carateres "f") produz os milionésimos de segundo num intervalo de tempo. Numa operação de formatação, os dígitos fracionários restantes são truncados. Numa operação de análise que chama o TimeSpan.ParseExact método ou TimeSpan.TryParseExact , a cadeia de entrada tem de conter exatamente seis dígitos fracionários.
O exemplo seguinte utiliza o especificador de formato personalizado "ffffff" para apresentar os milionésimos de segundo num TimeSpan valor. É utilizado primeiro como o único especificador de formato e, em seguida, combinado com o especificador "s" numa cadeia de formato personalizado.
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
O especificador de formato personalizado "fffffff"
O especificador de formato personalizado "fffffff" (com sete carateres "f") produz os dez milionésimos de segundo (ou o número fracionário de tiques) num intervalo de tempo. Numa operação de análise que chama o TimeSpan.ParseExact método ou TimeSpan.TryParseExact , a cadeia de entrada tem de conter exatamente sete dígitos fracionários.
O exemplo seguinte utiliza o especificador de formato personalizado "fffffff" para apresentar o número fracionário de tiques num TimeSpan valor. É utilizado primeiro como o único especificador de formato e, em seguida, combinado com o especificador "s" numa cadeia de formato personalizado.
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
O especificador de formato personalizado "F"
O especificador de formato personalizado "F" produz as décimas de segundo num intervalo de tempo. Numa operação de formatação, os dígitos fracionários restantes são truncados. Se o valor das décimas de um segundo do intervalo de tempo for zero, não será incluído na cadeia de resultados. Numa operação de análise que chama o TimeSpan.ParseExact método ou TimeSpan.TryParseExact , a presença das décimas de um segundo dígito é opcional.
Se o especificador de formato personalizado "F" for utilizado sozinho, especifique "%F" para que não seja mal interpretado como uma cadeia de formato padrão.
O exemplo seguinte utiliza o especificador de formato personalizado "F" para apresentar as décimas de um segundo num TimeSpan valor. Também utiliza este especificador de formato personalizado numa operação de análise.
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'.
O especificador de formato personalizado "FF"
O especificador de formato personalizado "FF" produz os centésimos de segundo num intervalo de tempo. Numa operação de formatação, os dígitos fracionários restantes são truncados. Se existirem zeros fracionários à direita, não serão incluídos na cadeia de resultados. Numa operação de análise que chama o TimeSpan.ParseExact método ou TimeSpan.TryParseExact , a presença das décimas e centésimas de um segundo dígito é opcional.
O exemplo seguinte utiliza o especificador de formato personalizado "FF" para apresentar as centésimos de segundo num TimeSpan valor. Também utiliza este especificador de formato personalizado numa operação de análise.
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'.
O especificador de formato personalizado "FFF"
O especificador de formato personalizado "FFF" (com três carateres "F") produz os milissegundos num intervalo de tempo. Numa operação de formatação, os dígitos fracionários restantes são truncados. Se existirem zeros fracionários à direita, não serão incluídos na cadeia de resultados. Numa operação de análise que chama o TimeSpan.ParseExact método ou TimeSpan.TryParseExact , a presença das décimas, centésimas e milésimas de segundo dígito é opcional.
O exemplo seguinte utiliza o especificador de formato personalizado "FFF" para apresentar os milésimos de segundo num TimeSpan valor. Também utiliza este especificador de formato personalizado numa operação de análise.
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'.
O especificador de formato personalizado "FFFF"
O especificador de formato personalizado "FFFF" (com quatro carateres "F") produz os dez milésimos de segundo num intervalo de tempo. Numa operação de formatação, os dígitos fracionários restantes são truncados. Se existirem zeros fracionários à direita, não serão incluídos na cadeia de resultados. Numa operação de análise que chama o TimeSpan.ParseExact método ou TimeSpan.TryParseExact , a presença dos décimos, centésimos, milésimos e dez milésimos de segundo dígito é opcional.
O exemplo seguinte utiliza o especificador de formato personalizado "FFFF" para apresentar os dez milésimos de segundo num TimeSpan valor. Também utiliza o especificador de formato personalizado "FFFF" numa operação de análise.
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'.
O especificador de formato personalizado "FFFFF"
O especificador de formato personalizado "FFFFF" (com cinco carateres "F") produz os centésimos milésimos de segundo num intervalo de tempo. Numa operação de formatação, os dígitos fracionários restantes são truncados. Se existirem zeros fracionários à direita, não serão incluídos na cadeia de resultados. Numa operação de análise que chama o TimeSpan.ParseExact método ou TimeSpan.TryParseExact , a presença dos décimos, centésimos, milésimos, dez milésimos e cem milésimos de segundo dígito é opcional.
O exemplo seguinte utiliza o especificador de formato personalizado "FFFFF" para apresentar as centenas de milésimos de segundo num TimeSpan valor. Também utiliza o especificador de formato personalizado "FFFFF" numa operação de análise.
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'.
O especificador de formato personalizado "FFFFFF"
O especificador de formato personalizado "FFFFFF" (com seis carateres "F") produz os milionésimos de segundo num intervalo de tempo. Numa operação de formatação, os dígitos fracionários restantes são truncados. Se existirem zeros fracionários à direita, não serão incluídos na cadeia de resultados. Numa operação de análise que chama o TimeSpan.ParseExact método ou TimeSpan.TryParseExact , a presença dos décimos, centésimos, milésimos, dez milésimos, cem milésimos e milésimos de segundo dígito é opcional.
O exemplo seguinte utiliza o especificador de formato personalizado "FFFFFF" para apresentar os milionésimos de segundo num TimeSpan valor. Também utiliza este especificador de formato personalizado numa operação de análise.
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'.
O especificador de formato personalizado "FFFFFFF"
O especificador de formato personalizado "FFFFFFF" (com sete carateres "F") produz os dez milionésimos de segundo (ou o número fracionário de tiques) num intervalo de tempo. Se existirem zeros fracionários à direita, não serão incluídos na cadeia de resultados. Numa operação de análise que chama o TimeSpan.ParseExact método ou TimeSpan.TryParseExact , a presença dos sete dígitos fracionários na cadeia de entrada é opcional.
O exemplo seguinte utiliza o especificador de formato personalizado "FFFFFFF" para apresentar as partes fracionárias de um segundo num TimeSpan valor. Também utiliza este especificador de formato personalizado numa operação de análise.
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
Outros carateres
Qualquer outro caráter não partilhado numa cadeia de formato, incluindo um caráter de espaço em branco, é interpretado como um especificador de formato personalizado. Na maioria dos casos, a presença de qualquer outro caráter não paisteres resulta num FormatException.
Existem duas formas de incluir um caráter literal numa cadeia de formato:
Coloque-o entre aspas individuais (o delimitador de cadeia literal).
Preceda-o com uma barra invertida ("\"), que é interpretada como um caráter de escape. Isto significa que, em C#, a cadeia de formato tem de ser @-quoted ou o caráter literal tem de ser precedido por uma barra invertida adicional.
Em alguns casos, poderá ter de utilizar a lógica condicional para incluir um literal em fuga numa cadeia de formato. O exemplo seguinte utiliza lógica condicional para incluir um símbolo de sinal para intervalos de tempo negativos.
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:54Module 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. Isto significa que os separadores entre dias e horas, horas e minutos, minutos e segundos e segundos e frações de um segundo têm de ser tratados como literais de carateres numa cadeia de formato.
O exemplo seguinte utiliza o caráter de escape e a plica para definir uma cadeia de formato personalizado que inclui a palavra "minutos" na cadeia de saída.
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
Ver também
Comentários
Brevemente: Ao longo de 2024, vamos descontinuar progressivamente o GitHub Issues como mecanismo de feedback para conteúdos e substituí-lo por um novo sistema de feedback. Para obter mais informações, veja: https://aka.ms/ContentUserFeedback.
Submeter e ver comentários