Partage via

Guide pratique pour afficher les millisecondes dans les valeurs de date et d’heure

  • Article

Les méthodes de mise en forme de date et d’heure par défaut, telles que DateTime.ToString(), incluent les heures, les minutes et les secondes d’une valeur d’heure, mais excluent son composant « millisecondes ». Cet article montre comment inclure le composant « millisecondes » d’une date et d’une heure dans des chaînes de date et d’heure mises en forme.

Pour afficher le composant « millisecondes » d’une valeur DateTime

  1. Si la date est représentée sous forme de chaîne, convertissez-la en une valeur DateTime ou DateTimeOffset en utilisant la méthode statique DateTime.Parse(String) ou DateTimeOffset.Parse(String).

  2. Pour extraire la représentation sous forme de chaîne du composant « millisecondes » d’une heure, appelez la méthode DateTime.ToString(String) ou ToString de la valeur de date et d’heure, puis passez le modèle de format personnalisé fff ou FFF seul ou avec d’autres spécificateurs de format personnalisé comme paramètre format.

Conseil

La propriété System.Globalization.NumberFormatInfo.NumberDecimalSeparator spécifie le séparateur de millisecondes.

Exemple

L’exemple affiche le composant « millisecondes » d’une valeur DateTime et d’une valeur DateTimeOffset sur la console, seul et inclus dans une chaîne de date et d’heure plus longue.

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

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"));

    string fullPattern = DateTimeFormatInfo.CurrentInfo.FullDateTimePattern;
    
    // Create a format similar to .fff but based on the current culture.
    string millisecondFormat = $"{NumberFormatInfo.CurrentInfo.NumberDecimalSeparator}fff";

    // Append millisecond pattern to current culture's full date time pattern.
    fullPattern = Regex.Replace(fullPattern, "(:ss|:s)", $"$1{millisecondFormat}");

    // 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"))

            Dim fullPattern As String = DateTimeFormatInfo.CurrentInfo.FullDateTimePattern

            ' Create a format similar to .fff but based on the current culture.
            Dim millisecondFormat as String = $"{NumberFormatInfo.CurrentInfo.NumberDecimalSeparator}fff"
            
            ' Append millisecond pattern to current culture's full date time pattern.
            fullPattern = Regex.Replace(fullPattern, "(:ss|:s)", $"$1{millisecondFormat}")

            ' 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

Le modèle de format fff inclut les zéros de fin éventuels dans la valeur en millisecondes. Le modèle de format FFF les supprime. L’exemple suivant illustre la différence :

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

Quand vous définissez un spécificateur de format personnalisé complet qui inclut le composant « millisecondes » d’une date et d’une heure, vous pouvez être confronté au problème suivant : le format défini est un format codé en dur qui peut ne pas correspondre à la disposition des éléments d’heure dans la culture actuelle de l’application. Une meilleure solution consiste à récupérer l’un des modèles d’affichage de la date et de l’heure définis par l’objet DateTimeFormatInfo de la culture actuelle et à le modifier pour inclure les millisecondes. L’exemple illustre également cette approche. Il récupère de la propriété DateTimeFormatInfo.FullDateTimePattern le modèle de date et d’heure complet de la culture actuelle, puis insère le modèle personnalisé fff avec le séparateur de millisecondes de la culture actuelle. L’exemple utilise une expression régulière pour effectuer cette opération dans un seul appel de méthode.

Vous pouvez également utiliser un spécificateur de format personnalisé pour afficher une partie fractionnaire des secondes autre que les millisecondes. Par exemple, le spécificateur de format personnalisé f ou F affiche les dixièmes de seconde, le spécificateur de format personnalisé ff ou FF affiche les centièmes de seconde, tandis que le spécificateur de format personnalisé ffff ou FFFF affiche les dix millièmes de seconde. La partie fractionnaire d’une milliseconde est tronquée au lieu d’être arrondie dans la chaîne retournée. Ces spécificateurs de format sont utilisés dans l’exemple suivant :

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

Notes

Il est possible d’afficher de très petites unités fractionnaires d’une seconde, telles que les dix millièmes de seconde ou les cent millièmes de seconde. Toutefois, ces valeurs risquent de ne pas être significatives. La précision d’une valeur de date et d’heure dépend de la résolution de l’horloge du système d’exploitation. Pour plus d’informations, consultez la documentation de l’API utilisée par votre système d’exploitation :

Voir aussi