Como: Exibir milissegundos em valores de data e horaHow to: Display Milliseconds in Date and Time Values

Os métodos padrão de formatação de data e hora, como DateTime.ToString(), incluem as horas, minutos e segundos de um valor temporal, mas excluem seu componente de milissegundos.The default date and time formatting methods, such as DateTime.ToString(), include the hours, minutes, and seconds of a time value but exclude its milliseconds component. Este tópico mostra como incluir um componente de milissegundos de uma data e hora em cadeias de caracteres de data e hora formatadas.This topic shows how to include a date and time's millisecond component in formatted date and time strings.

Para exibir o componente de milissegundos de um valor DateTimeTo display the millisecond component of a DateTime value

  1. Se você estiver trabalhando na representação da cadeia de caracteres de uma data, converta-a para um valor DateTime ou DateTimeOffset usando a estatística DateTime.Parse(String) ou o método DateTimeOffset.Parse(String).If you are working with the string representation of a date, convert it to a DateTime or a DateTimeOffset value by using the static DateTime.Parse(String) or DateTimeOffset.Parse(String) method.

  2. Para extrair a representação de cadeia de caracteres do componente de milissegundos de um valor de data e hora, chame o método DateTime.ToString(String) ou ToString do valor de data e hora e passe o padrão de formato personalizado fff ou FFF, sozinho ou com outros especificadores de formato personalizado como o parâmetro format.To extract the string representation of a time's millisecond component, call the date and time value's DateTime.ToString(String) or ToString method, and pass the fff or FFF custom format pattern either alone or with other custom format specifiers as the format parameter.

ExemploExample

O exemplo exibe o componente de milissegundos de um valor de DateTime e DateTimeOffset para console, sozinho e incluído em uma cadeia de caracteres de data e hora mais longa.The example displays the millisecond component of a DateTime and a DateTimeOffset value to the console, both alone and included in a longer date and time string.

using System;
using System.Globalization;
using System.Text.RegularExpressions;

public class MillisecondDisplay
{
   public static void Main()
   {
      string dateString = "7/16/2008 8:32:45.126 AM";

      try
      {
         DateTime dateValue = DateTime.Parse(dateString);
         DateTimeOffset dateOffsetValue = DateTimeOffset.Parse(dateString);

         // Display Millisecond component alone.
         Console.WriteLine("Millisecond component only: {0}",
                           dateValue.ToString("fff"));
         Console.WriteLine("Millisecond component only: {0}",
                           dateOffsetValue.ToString("fff"));

         // Display Millisecond component with full date and time.
         Console.WriteLine("Date and Time with Milliseconds: {0}",
                           dateValue.ToString("MM/dd/yyyy hh:mm:ss.fff tt"));
         Console.WriteLine("Date and Time with Milliseconds: {0}",
                           dateOffsetValue.ToString("MM/dd/yyyy hh:mm:ss.fff tt"));

         // Append millisecond pattern to current culture's full date time pattern
         string fullPattern = DateTimeFormatInfo.CurrentInfo.FullDateTimePattern;
         fullPattern = Regex.Replace(fullPattern, "(:ss|:s)", "$1.fff");

         // Display Millisecond component with modified full date and time pattern.
         Console.WriteLine("Modified full date time pattern: {0}",
                           dateValue.ToString(fullPattern));
         Console.WriteLine("Modified full date time pattern: {0}",
                           dateOffsetValue.ToString(fullPattern));
      }
      catch (FormatException)
      {
         Console.WriteLine("Unable to convert {0} to a date.", dateString);
      }
   }
}
// The example displays the following output if the current culture is en-US:
//    Millisecond component only: 126
//    Millisecond component only: 126
//    Date and Time with Milliseconds: 07/16/2008 08:32:45.126 AM
//    Date and Time with Milliseconds: 07/16/2008 08:32:45.126 AM
//    Modified full date time pattern: Wednesday, July 16, 2008 8:32:45.126 AM
//    Modified full date time pattern: Wednesday, July 16, 2008 8:32:45.126 AM
Imports System.Globalization
Imports System.Text.REgularExpressions

Module MillisecondDisplay
    Public Sub Main()

        Dim dateString As String = "7/16/2008 8:32:45.126 AM"

        Try
            Dim dateValue As Date = Date.Parse(dateString)
            Dim dateOffsetValue As DateTimeOffset = DateTimeOffset.Parse(dateString)

            ' Display Millisecond component alone.
            Console.WriteLine("Millisecond component only: {0}", _
                              dateValue.ToString("fff"))
            Console.WriteLine("Millisecond component only: {0}", _
                              dateOffsetValue.ToString("fff"))

            ' Display Millisecond component with full date and time.
            Console.WriteLine("Date and Time with Milliseconds: {0}", _
                              dateValue.ToString("MM/dd/yyyy hh:mm:ss.fff tt"))
            Console.WriteLine("Date and Time with Milliseconds: {0}", _
                              dateOffsetValue.ToString("MM/dd/yyyy hh:mm:ss.fff tt"))

            ' Append millisecond pattern to current culture's full date time pattern
            Dim fullPattern As String = DateTimeFormatInfo.CurrentInfo.FullDateTimePattern
            fullPattern = Regex.Replace(fullPattern, "(:ss|:s)", "$1.fff")

            ' Display Millisecond component with modified full date and time pattern.
            Console.WriteLine("Modified full date time pattern: {0}", _
                              dateValue.ToString(fullPattern))
            Console.WriteLine("Modified full date time pattern: {0}", _
                              dateOffsetValue.ToString(fullPattern))
        Catch e As FormatException
            Console.WriteLine("Unable to convert {0} to a date.", dateString)
        End Try
    End Sub
End Module
' The example displays the following output if the current culture is en-US:
'    Millisecond component only: 126
'    Millisecond component only: 126
'    Date and Time with Milliseconds: 07/16/2008 08:32:45.126 AM
'    Date and Time with Milliseconds: 07/16/2008 08:32:45.126 AM
'    Modified full date time pattern: Wednesday, July 16, 2008 8:32:45.126 AM
'    Modified full date time pattern: Wednesday, July 16, 2008 8:32:45.126 AM

O padrão de formato fff inclui os zeros à direita no valor de milissegundos.The fff format pattern includes any trailing zeros in the millisecond value. O padrão de formato FFF os suprime.The FFF format pattern suppresses them. A diferença é ilustrada no exemplo a seguir.The difference is illustrated in the following example.

DateTime dateValue = new DateTime(2008, 7, 16, 8, 32, 45, 180);
Console.WriteLine(dateValue.ToString("fff"));
Console.WriteLine(dateValue.ToString("FFF"));
// The example displays the following output to the console:
//    180
//    18
Dim dateValue As New Date(2008, 7, 16, 8, 32, 45, 180)
Console.WriteLIne(dateValue.ToString("fff"))
Console.WriteLine(dateValue.ToString("FFF"))
' The example displays the following output to the console:
'    180
'    18      

Um problema ao definir um especificador de formato personalizado completo que inclui o componente de milissegundos de uma data e hora é que ele define um formato embutido em código que pode não corresponder à organização de elementos de hora na cultura atual do aplicativo.A problem with defining a complete custom format specifier that includes the millisecond component of a date and time is that it defines a hard-coded format that may not correspond to the arrangement of time elements in the application's current culture. Uma alternativa melhor é recuperar um dos padrões de exibição de data e hora definidos pelo objeto DateTimeFormatInfo da cultura atual e modificá-lo para incluir milissegundos.A better alternative is to retrieve one of the date and time display patterns defined by the current culture's DateTimeFormatInfo object and modify it to include milliseconds. O exemplo também ilustra esta abordagem.The example also illustrates this approach. Ele recupera o padrão de data e hora completo da cultura atual da propriedade DateTimeFormatInfo.FullDateTimePattern e insere o padrão personalizado .ffff após seu padrão de segundos.It retrieves the current culture's full date and time pattern from the DateTimeFormatInfo.FullDateTimePattern property, and then inserts the custom pattern .ffff after its seconds pattern. Observe que o exemplo usa uma expressão regular para executar esta operação em uma única chamada de método.Note that the example uses a regular expression to perform this operation in a single method call.

Você também pode usar um especificador de formato personalizado para exibir uma parte fracionária dos segundos que não sejam milissegundos.You can also use a custom format specifier to display a fractional part of seconds other than milliseconds. Por exemplo, o especificador de formato personalizado f ou F exibe décimos de segundo, o especificador de formato personalizado ff ou FF exibe centésimos de segundo e o especificador de formato personalizado ffff ou FFFF exibe décimos de milésimos de segundo.For example, the f or F custom format specifier displays tenths of a second, the ff or FF custom format specifier displays hundredths of a second, and the ffff or FFFF custom format specifier displays ten thousandths of a second. Partes fracionárias de um milissegundo são truncadas em vez de arredondadas na cadeia de caracteres retornada.Fractional parts of a millisecond are truncated instead of rounded in the returned string. Esses especificadores de formato são usados no exemplo a seguir.These format specifiers are used in the following example.

DateTime dateValue = new DateTime(2008, 7, 16, 8, 32, 45, 180);
Console.WriteLine("{0} seconds", dateValue.ToString("s.f"));
Console.WriteLine("{0} seconds", dateValue.ToString("s.ff"));
Console.WriteLine("{0} seconds", dateValue.ToString("s.ffff"));
// The example displays the following output to the console:
//    45.1 seconds
//    45.18 seconds
//    45.1800 seconds
Dim dateValue As New DateTime(2008, 7, 16, 8, 32, 45, 180)
Console.WriteLine("{0} seconds", dateValue.ToString("s.f"))
Console.WriteLine("{0} seconds", dateValue.ToString("s.ff"))
Console.WriteLine("{0} seconds", dateValue.ToString("s.ffff"))
' The example displays the following output to the console:
'    45.1 seconds
'    45.18 seconds
'    45.1800 seconds

Observação

É possível exibir unidades fracionárias muito pequenas de um segundo, como dez milésimos de segundo ou centésimos de milésimos de segundo.It is possible to display very small fractional units of a second, such as ten thousandths of a second or hundred-thousandths of a second. No entanto, esses valores podem não ser significativos.However, these values may not be meaningful. A precisão dos valores de data e hora depende da resolução do relação ao relógio do sistema.The precision of date and time values depends on the resolution of the system clock. No Windows NT 3,5 e versões posteriores e sistemas operacionais Windows Vista, a resolução do relógio é de aproximadamente 10-15 milissegundos.On Windows NT 3.5 and later, and Windows Vista operating systems, the clock's resolution is approximately 10-15 milliseconds.

Confira tambémSee also