Condividi tramite

Procedura: Visualizzare i millisecondi nei valori data e ora

  • Articolo

I metodi di formattazione di data e ora predefiniti, ad esempio DateTime.ToString(), includono le ore, i minuti e i secondi di un valore di ora, ma ne escludono il componente dei millisecondi. Questo articolo descrive come includere un componente dei millisecondi di una data e un'ora nelle stringhe di data e ora formattate.

Per visualizzare il componente millisecondi di un valore DateTime

  1. Se si usa la rappresentazione di stringa di una data, convertirla in un valore DateTime o DateTimeOffset tramite il metodo statico DateTime.Parse(String) o DateTimeOffset.Parse(String).

  2. Per estrarre la rappresentazione di stringa del componente dei millisecondi di un'ora, chiamare il metodo DateTime.ToString(String) o ToString del valore di data e ora e passare il criterio di formato personalizzato fff o FFF da solo o con altri identificatori di formato personalizzato come parametro format.

Suggerimento

La proprietà System.Globalization.NumberFormatInfo.NumberDecimalSeparator specifica il separatore di millisecondi.

Esempio

L'esempio visualizza il componente dei millisecondi di un valore DateTime e di un valore DateTimeOffset alla console, da solo e incluso in una stringa di data e ora più lunga.

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

Il modello di formato fff include gli zeri finali nei millisecondi. Il modello di formato FFF li elimina. L'esempio seguente illustra la differenza:

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

Uno dei problemi della definizione di un identificatore di formato personalizzato completo che include il componente dei millisecondi di una data e ora è rappresentato dal fatto che l'identificatore definisce un formato hardcoded che potrebbe non corrispondere alla disposizione degli elementi relativi all'ora delle impostazioni cultura correnti dell'applicazione. Un'alternativa migliore consiste nel recuperare uno dei modelli di visualizzazione di data e ora definiti dall'oggetto DateTimeFormatInfo delle impostazioni cultura correnti e modificarlo in modo da includere i millisecondi. L'esempio illustra anche questo approccio. L'esempio recupera il criterio di data e ora completo delle impostazioni cultura correnti dalla proprietà DateTimeFormatInfo.FullDateTimePattern e quindi inserisce il criterio personalizzato fff dopo il separatore di millisecondi delle impostazioni cultura correnti. L'esempio usa un'espressione regolare per eseguire questa operazione in una singola chiamata al metodo.

È anche possibile usare un identificatore di formato personalizzato per visualizzare una parte frazionaria di secondi diversa dai millisecondi. Ad esempio, l'identificatore di formato personalizzato f o F visualizza i decimi di secondo, l'identificatore di formato personalizzato ff o FF i centesimi di secondo e l'identificatore di formato personalizzato ffff o FFFF i decimillesimi di secondo. Le parti frazionarie di un millisecondo vengono troncate anziché arrotondate nella stringa restituita. Questi identificatori di formato vengono usati nell'esempio seguente:

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

Nota

È possibile visualizzare piccolissime unità di secondo frazionarie, come decimillesimi di secondo o centomillesimi di secondo. Questi valori tuttavia potrebbero non essere significativi. La precisione dei valori di data e ora dipende dalla risoluzione dell'orologio del sistema operativo. Per altre informazioni, vedere l'API usata dal sistema operativo:

Vedi anche