TimeSpan.ToString Método

Definição

Espaço de Nomes:: System

Assemblagens:: mscorlib.dll, System.Runtime.dll

Assemblagens:: netstandard.dll, System.Runtime.dll

Assemblagem:: System.Runtime.dll

Assemblagem:: mscorlib.dll

Assemblagem:: netstandard.dll

Importante

Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.

Converte o valor do objeto atual TimeSpan para a sua representação equivalente em cadeias.

Sobrecargas

Name	Description
ToString()	Converte o valor do objeto atual TimeSpan para a sua representação equivalente em cadeias.
ToString(String)	Converte o valor do objeto atual TimeSpan para a sua representação equivalente em cadeia usando o formato especificado.
ToString(String, IFormatProvider)	Converte o valor do objeto atual TimeSpan para a sua representação equivalente de cadeias usando o formato especificado e a informação de formatação específica da cultura.

ToString()

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Converte o valor do objeto atual TimeSpan para a sua representação equivalente em cadeias.

public:
 override System::String ^ ToString();

public override string ToString();

override this.ToString : unit -> string

Public Overrides Function ToString () As String

Devoluções

String

A representação da cadeia do valor atual TimeSpan .

Exemplos

O exemplo seguinte mostra as cadeias devolvidas ao chamar o ToString método com vários TimeSpan valores. Note-se que, embora o exemplo não chame diretamente o ToString método, é chamado pelo Console.WriteLine método quando tenta converter um TimeSpan valor para a sua representação de cadeia.

 TimeSpan span;
 
 // Initialize a time span to zero.
 span = TimeSpan.Zero;
 Console.WriteLine(span);

 // Initialize a time span to 14 days.
 span = new TimeSpan(-14, 0, 0, 0, 0);
 Console.WriteLine(span);

 // Initialize a time span to 1:02:03.
 span = new TimeSpan(1, 2, 3);
 Console.WriteLine(span);

 // Initialize a time span to 250 milliseconds.
 span = new TimeSpan(0, 0, 0, 0, 250);
 Console.WriteLine(span);
 
 // Initialize a time span to 99 days, 23 hours, 59 minutes, and 59.999 seconds.
 span = new TimeSpan(99, 23, 59, 59, 999);
 Console.WriteLine(span);
 
 // Initialize a time span to 3 hours.
 span = new TimeSpan(3, 0, 0);
 Console.WriteLine(span);
 
 // Initialize a timespan to 25 milliseconds.
 span = new TimeSpan(0, 0, 0, 0, 25);
 Console.WriteLine(span);

 // The example displays the following output:
 //       00:00:00
 //       -14.00:00:00
 //       01:02:03
 //       00:00:00.2500000
 //       99.23:59:59.9990000
 //       03:00:00
 //       00:00:00.0250000

// Initialize a time span to zero.
let span = TimeSpan.Zero
printfn $"{span}"

// Initialize a time span to 14 days.
let span = TimeSpan(-14, 0, 0, 0, 0)
printfn $"{span}"

// Initialize a time span to 1:02:03.
let span = TimeSpan(1, 2, 3)
printfn $"{span}"

// Initialize a time span to 250 milliseconds.
let span = TimeSpan(0, 0, 0, 0, 250)
printfn $"{span}"

// Initialize a time span to 99 days, 23 hours, 59 minutes, and 59.999 seconds.
let span = TimeSpan(99, 23, 59, 59, 999)
printfn $"{span}"

// Initialize a time span to 3 hours.
let span = TimeSpan(3, 0, 0)
printfn $"{span}"

// Initialize a timespan to 25 milliseconds.
let span = TimeSpan(0, 0, 0, 0, 25)
printfn $"{span}"

// The example displays the following output:
//       00:00:00
//       -14.00:00:00
//       01:02:03
//       00:00:00.2500000
//       99.23:59:59.9990000
//       03:00:00
//       00:00:00.0250000

Module ToString
   Public Sub Main()
      Dim span As TimeSpan
      
      ' Initialize a time span to zero.
      span = TimeSpan.Zero
      Console.WriteLine(span)
      
      ' Initialize a time span to 14 days.
      span = New TimeSpan(-14, 0, 0, 0, 0)
      Console.WriteLine(span)
     
      ' Initialize a time span to 1:02:03.
      span = New TimeSpan(1, 2, 3)
      Console.WriteLine(span)
      
      
      ' Initialize a time span to 250 milliseconds.
      span = New TimeSpan(0, 0, 0, 0, 250)
      Console.WriteLine(span)
      
      ' Initialize a time span to 99 days, 23 hours, 59 minutes, and 59.9999999 seconds.
      span = New TimeSpan(99, 23, 59, 59, 999)
      Console.WriteLine(span)
      
      ' Initialize a time span to 3 hours.
      span = New TimeSpan(3, 0, 0)
      Console.WriteLine(span)
      
      ' Initialize a timespan to 25 milliseconds.
      span = New TimeSpan(0, 0, 0, 0, 25)
      Console.WriteLine(span)
   End Sub
End Module
' The example displays the following output:
'       00:00:00
'       -14.00:00:00
'       01:02:03
'       00:00:00.2500000
'       99.23:59:59.9990000
'       03:00:00
'       00:00:00.0250000

Observações

A cadeia devolvida é formatada com o especificador de formato "c" e tem o seguinte formato:

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

Elementos entre parênteses ([ e ]) não podem ser incluídos na sequência devolvida. Dois pontos e pontos (: e.) são caracteres literais. Os elementos não literais estão listados na tabela seguinte. Note-se que a cadeia devolvida pelo ToString() método não é sensível à cultura.

Iteme	Descrição
"-"	Um sinal de menos, que indica um intervalo de tempo negativo. Não é incluído nenhum sinal durante um período positivo.
"d"	O número de dias no intervalo de tempo. Este elemento é omitido se o intervalo de tempo for inferior a um dia.
"hh"	O número de horas no intervalo de tempo, variando de 0 a 23.
"mm"	O número de minutos no intervalo de tempo, variando de 0 a 59.
"ss"	O número de segundos no intervalo de tempo, variando de 0 a 59.
"fffffff"	Frações de segundo no intervalo de tempo. Este elemento é omitido se o intervalo de tempo não incluir frações de segundos. Se presente, os segundos fracionários são sempre expressos usando sete dígitos decimais.

Notas para Chamadores

O suporte para formatação de valores TimeSpan foi adicionado no .NET Framework 4. No entanto, a ToString() sobrecarga de métodos mantém-se insensível à cultura. O seu comportamento mantém-se inalterado em relação às versões anteriores do .NET Framework. Para controlar a formatação de um TimeSpan valor, chame o ToString(String) or ToString(String, IFormatProvider) overload.

Ver também

Aplica-se a

ToString(String)

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Converte o valor do objeto atual TimeSpan para a sua representação equivalente em cadeia usando o formato especificado.

public:
 System::String ^ ToString(System::String ^ format);

public string ToString(string format);

public string ToString(string? format);

override this.ToString : string -> string

Public Function ToString (format As String) As String

Parâmetros

format: String

Uma cadeia de formatos padrão ou personalizada TimeSpan .

Devoluções

String

A representação da cadeia do valor atual TimeSpan no formato especificado pelo format parâmetro.

Exceções

FormatException

O format parâmetro não é reconhecido ou não é suportado.

Exemplos

O exemplo seguinte utiliza cadeias de formatos padrão e personalizadas TimeSpan para mostrar a representação das cadeias de cada elemento num array de TimeSpan valores

TimeSpan[] spans = { 
   TimeSpan.Zero, 
   new TimeSpan(-14, 0, 0, 0, 0), 
   new TimeSpan(1, 2, 3), 
   new TimeSpan(0, 0, 0, 0, 250), 
   new TimeSpan(99, 23, 59, 59, 999),
   new TimeSpan(3, 0, 0), 
   new TimeSpan(0, 0, 0, 0, 25) 
};

string[] fmts = { "c", "g", "G", @"hh\:mm\:ss", "%m' min.'" };
foreach (TimeSpan span in spans)
{
   foreach (string fmt in fmts)
      Console.WriteLine("{0}: {1}", fmt, span.ToString(fmt));

   Console.WriteLine();
}
// The example displays the following output:
//       c: 00:00:00
//       g: 0:00:00
//       G: 0:00:00:00.0000000
//       hh\:mm\:ss: 00:00:00
//       %m' min.': 0 min.
//       
//       c: -14.00:00:00
//       g: -14:0:00:00
//       G: -14:00:00:00.0000000
//       hh\:mm\:ss: 00:00:00
//       %m' min.': 0 min.
//       
//       c: 01:02:03
//       g: 1:02:03
//       G: 0:01:02:03.0000000
//       hh\:mm\:ss: 01:02:03
//       %m' min.': 2 min.
//       
//       c: 00:00:00.2500000
//       g: 0:00:00.25
//       G: 0:00:00:00.2500000
//       hh\:mm\:ss: 00:00:00
//       %m' min.': 0 min.
//       
//       c: 99.23:59:59.9990000
//       g: 99:23:59:59.999
//       G: 99:23:59:59.9990000
//       hh\:mm\:ss: 23:59:59
//       %m' min.': 59 min.
//       
//       c: 03:00:00
//       g: 3:00:00
//       G: 0:03:00:00.0000000
//       hh\:mm\:ss: 03:00:00
//       %m' min.': 0 min.
//       
//       c: 00:00:00.0250000
//       g: 0:00:00.025
//       G: 0:00:00:00.0250000
//       hh\:mm\:ss: 00:00:00
//       %m' min.': 0 min.

let spans = 
    [| TimeSpan.Zero
       TimeSpan(-14, 0, 0, 0, 0)
       TimeSpan(1, 2, 3)
       TimeSpan(0, 0, 0, 0, 250)
       TimeSpan(99, 23, 59, 59, 999)
       TimeSpan(3, 0, 0)
       TimeSpan(0, 0, 0, 0, 25) |]


let fmts = [| "c"; "g"; "G"; @"hh\:mm\:ss"; "%m' min.'" |]
for span in spans do
    for fmt in fmts do
        printfn $"{fmt}: {span.ToString fmt}"
    printfn ""
// The example displays the following output:
//       c: 00:00:00
//       g: 0:00:00
//       G: 0:00:00:00.0000000
//       hh\:mm\:ss: 00:00:00
//       %m' min.': 0 min.
//       
//       c: -14.00:00:00
//       g: -14:0:00:00
//       G: -14:00:00:00.0000000
//       hh\:mm\:ss: 00:00:00
//       %m' min.': 0 min.
//       
//       c: 01:02:03
//       g: 1:02:03
//       G: 0:01:02:03.0000000
//       hh\:mm\:ss: 01:02:03
//       %m' min.': 2 min.
//       
//       c: 00:00:00.2500000
//       g: 0:00:00.25
//       G: 0:00:00:00.2500000
//       hh\:mm\:ss: 00:00:00
//       %m' min.': 0 min.
//       
//       c: 99.23:59:59.9990000
//       g: 99:23:59:59.999
//       G: 99:23:59:59.9990000
//       hh\:mm\:ss: 23:59:59
//       %m' min.': 59 min.
//       
//       c: 03:00:00
//       g: 3:00:00
//       G: 0:03:00:00.0000000
//       hh\:mm\:ss: 03:00:00
//       %m' min.': 0 min.
//       
//       c: 00:00:00.0250000
//       g: 0:00:00.025
//       G: 0:00:00:00.0250000
//       hh\:mm\:ss: 00:00:00
//       %m' min.': 0 min.

Module Example
   Public Sub Main()
      Dim spans() As TimeSpan = { TimeSpan.Zero, New TimeSpan(-14, 0, 0, 0, 0), 
                                  New TimeSpan(1, 2, 3), 
                                  New TimeSpan(0, 0, 0, 0, 250), 
                                  New TimeSpan(99, 23, 59, 59, 999),
                                  New TimeSpan(3, 0, 0), 
                                  New TimeSpan(0, 0, 0, 0, 25) }
      Dim fmts() As String = { "c", "g", "G", "hh\:mm\:ss", "%m' min.'" }
      For Each span As TimeSpan In spans
         For Each fmt As String In fmts
            Console.WriteLine("{0}: {1}", fmt, span.ToString(fmt))
         Next
         Console.WriteLine()         
      Next
   End Sub
End Module
' The example displays the following output:
'       c: 00:00:00
'       g: 0:00:00
'       G: 0:00:00:00.0000000
'       hh\:mm\:ss: 00:00:00
'       %m' min.': 0 min.
'       
'       c: -14.00:00:00
'       g: -14:0:00:00
'       G: -14:00:00:00.0000000
'       hh\:mm\:ss: 00:00:00
'       %m' min.': 0 min.
'       
'       c: 01:02:03
'       g: 1:02:03
'       G: 0:01:02:03.0000000
'       hh\:mm\:ss: 01:02:03
'       %m' min.': 2 min.
'       
'       c: 00:00:00.2500000
'       g: 0:00:00.25
'       G: 0:00:00:00.2500000
'       hh\:mm\:ss: 00:00:00
'       %m' min.': 0 min.
'       
'       c: 99.23:59:59.9990000
'       g: 99:23:59:59.999
'       G: 99:23:59:59.9990000
'       hh\:mm\:ss: 23:59:59
'       %m' min.': 59 min.
'       
'       c: 03:00:00
'       g: 3:00:00
'       G: 0:03:00:00.0000000
'       hh\:mm\:ss: 03:00:00
'       %m' min.': 0 min.
'       
'       c: 00:00:00.0250000
'       g: 0:00:00.025
'       G: 0:00:00:00.0250000
'       hh\:mm\:ss: 00:00:00
'       %m' min.': 0 min.

Observações

O format parâmetro pode ser qualquer padrão válido ou especificador de formato personalizado para TimeSpan valores. Se format for igual a String.Empty ou for null, o valor de retorno do objeto atual TimeSpan é formatado com o especificador de formato comum ("c"). Se format for qualquer outro valor, o método gera um FormatException.

Se format for uma cadeia de formato padrão, o formato da cadeia devolvida é definido pelas convenções de formatação da cultura atual.

Importante

As cadeias de formato personalizadas para TimeSpan valores não incluem separador de data ou hora. Se quiser incluir estes elementos na sua string de formato, deve tratá-los como literais de caracteres. Veja o exemplo para uma ilustração e consulte o tópico Custom TimeSpan Format Strings para mais informações.

O .NET oferece um suporte extenso de formatação, que é descrito com mais detalhe nos seguintes tópicos de formatação:

Para mais informações sobre cadeias de formatos para TimeSpan valores, consulte Cadeias de Formato Padrão TimeSpan e Cadeias de Formato TimeSpan Personalizadas.
Para mais informações sobre o suporte à formatação em .NET, consulte Formatting Types.

Ver também

Aplica-se a

ToString(String, IFormatProvider)

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Origem:: TimeSpan.cs

Converte o valor do objeto atual TimeSpan para a sua representação equivalente de cadeias usando o formato especificado e a informação de formatação específica da cultura.

public:
 virtual System::String ^ ToString(System::String ^ format, IFormatProvider ^ formatProvider);

public string ToString(string format, IFormatProvider formatProvider);

public string ToString(string? format, IFormatProvider? formatProvider);

override this.ToString : string * IFormatProvider -> string

Public Function ToString (format As String, formatProvider As IFormatProvider) As String

Parâmetros

format: String

Uma cadeia de formatos padrão ou personalizada TimeSpan .

formatProvider: IFormatProvider

Um objeto que fornece informação de formatação específica para cada cultura.

Devoluções

String

A representação da cadeia do valor atual TimeSpan , conforme especificado por format e formatProvider.

Implementações

ToString(String, IFormatProvider)

Exceções

FormatException

O format parâmetro não é reconhecido ou não é suportado.

Exemplos

O exemplo seguinte chama o ToString(String, IFormatProvider) método para formatar dois intervalos de tempo. O exemplo chama o método duas vezes para cada cadeia de formato, primeiro para o mostrar usando as convenções da cultura en-US e depois para o mostrar usando as convenções da cultura fr-FR.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      TimeSpan[] intervals = { new TimeSpan(38, 30, 15), 
                               new TimeSpan(16, 14, 30) }; 
      CultureInfo[] cultures = { new CultureInfo("en-US"), 
                                 new CultureInfo("fr-FR") };
      string[] formats = {"c", "g", "G", @"hh\:mm\:ss" };
      Console.WriteLine("{0,12}      Format  {1,22}  {2,22}\n", 
                        "Interval", cultures[0].Name, cultures[1].Name);

      foreach (var interval in intervals) {
         foreach (var fmt in formats)
            Console.WriteLine("{0,12}  {1,10}  {2,22}  {3,22}", 
                              interval, fmt, 
                              interval.ToString(fmt, cultures[0]), 
                              interval.ToString(fmt, cultures[1]));
         Console.WriteLine();
      }  
   }
}
// The example displays the following output:
//        Interval      Format                   en-US                   fr-FR
//    
//      1.14:30:15           c              1.14:30:15              1.14:30:15
//      1.14:30:15           g              1:14:30:15              1:14:30:15
//      1.14:30:15           G      1:14:30:15.0000000      1:14:30:15,0000000
//      1.14:30:15  hh\:mm\:ss                14:30:15                14:30:15
//    
//        16:14:30           c                16:14:30                16:14:30
//        16:14:30           g                16:14:30                16:14:30
//        16:14:30           G      0:16:14:30.0000000      0:16:14:30,0000000
//        16:14:30  hh\:mm\:ss                16:14:30                16:14:30

open System
open System.Globalization

let intervals = 
    [| TimeSpan(38, 30, 15)
       TimeSpan(16, 14, 30) |] 
let cultures = 
    [| CultureInfo "en-US"
       CultureInfo "fr-FR" |]
let formats = [| "c"; "g"; "G"; @"hh\:mm\:ss" |]
printfn $"""{"Interval",12}      Format  {cultures[0].Name,22}  {cultures[1].Name,22}\n""" 

for interval in intervals do
    for fmt in formats do
        printfn $"{interval,12}  {fmt,10}  {interval.ToString(fmt, cultures[0]),22}  {interval.ToString(fmt, cultures[1]),22}"
    printfn ""
// The example displays the following output:
//        Interval      Format                   en-US                   fr-FR
//    
//      1.14:30:15           c              1.14:30:15              1.14:30:15
//      1.14:30:15           g              1:14:30:15              1:14:30:15
//      1.14:30:15           G      1:14:30:15.0000000      1:14:30:15,0000000
//      1.14:30:15  hh\:mm\:ss                14:30:15                14:30:15
//    
//        16:14:30           c                16:14:30                16:14:30
//        16:14:30           g                16:14:30                16:14:30
//        16:14:30           G      0:16:14:30.0000000      0:16:14:30,0000000
//        16:14:30  hh\:mm\:ss                16:14:30                16:14:30

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim intervals() As TimeSpan = { New TimeSpan(38, 30, 15), 
                                      New TimeSpan(16, 14, 30) } 
      Dim cultures() As CultureInfo = { New CultureInfo("en-US"), 
                                        New CultureInfo("fr-FR") }
      Dim formats() As String = {"c", "g", "G", "hh\:mm\:ss" }
      Console.WriteLine("{0,12}      Format  {1,22}  {2,22}", 
                        "Interval", cultures(0).Name, cultures(1).Name)
      Console.WriteLine()
      For Each interval In intervals
         For Each fmt In formats
            Console.WriteLine("{0,12}  {1,10}  {2,22}  {3,22}", 
                              interval, fmt, 
                              interval.ToString(fmt, cultures(0)), 
                              interval.ToString(fmt, cultures(1)))
         Next
         Console.WriteLine()
      Next                                                                                                                                            
   End Sub
End Module
' The example displays the following output:
'        Interval      Format                   en-US                   fr-FR
'    
'      1.14:30:15           c              1.14:30:15              1.14:30:15
'      1.14:30:15           g              1:14:30:15              1:14:30:15
'      1.14:30:15           G      1:14:30:15.0000000      1:14:30:15,0000000
'      1.14:30:15  hh\:mm\:ss                14:30:15                14:30:15
'    
'        16:14:30           c                16:14:30                16:14:30
'        16:14:30           g                16:14:30                16:14:30
'        16:14:30           G      0:16:14:30.0000000      0:16:14:30,0000000
'        16:14:30  hh\:mm\:ss                16:14:30                16:14:30

Observações

O format parâmetro pode ser qualquer padrão válido ou especificador de formato personalizado para TimeSpan valores. Se format for igual a String.Empty ou for null, o valor de retorno do objeto atual TimeSpan é formatado com o especificador de formato comum ("c"). Se o formato for qualquer outro valor, o método lança um FormatException.

Importante

O .NET oferece um suporte extenso de formatação, que é descrito com mais detalhe nos seguintes tópicos de formatação:

Para mais informações sobre cadeias de formatos para TimeSpan valores, consulte Cadeias de Formato Padrão TimeSpan e Cadeias de Formato TimeSpan Personalizadas.
Para mais informações sobre o suporte à formatação em .NET, consulte Formatting Types.

O formatProvider parâmetro é uma IFormatProvider implementação que fornece informações específicas da cultura sobre o formato da cadeia de caracteres retornada. O formatProvider parâmetro pode ser qualquer um dos seguintes:

Um CultureInfo objeto que representa a cultura cujas convenções de formatação devem ser refletidas na cadeia de caracteres retornada. O DateTimeFormatInfo objeto retornado pela CultureInfo.DateTimeFormat propriedade define a formatação da cadeia de caracteres retornada.
Um DateTimeFormatInfo objeto que define a formatação da cadeia de caracteres retornada.
Um objeto personalizado que implementa a IFormatProvider interface. O método IFormatProvider.GetFormat retorna um objeto DateTimeFormatInfo que fornece informações de formatação.

Se formatProvider é null, o objeto DateTimeFormatInfo associado à cultura atual é usado. Se format for uma cadeia de formatos personalizada, o formatProvider parâmetro é ignorado.

Ver também

Aplica-se a

Comentários

Esta página foi útil?