Condividi tramite

Procedura: visualizzare il componente millisecondi dei valori data e ora

  • Articolo

Aggiornamento: novembre 2007

I metodi di formattazione di data e ora predefiniti, come DateTime.ToString(), includono le ore, i minuti e i secondi di un valore di ora ma ne escludono il componente millisecondi. In questo argomento viene illustrato come includere un componente 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 sta lavorando alla rappresentazione di stringa di una data, convertirla in un valore DateTime o in un valore DateTimeOffset utilizzando il metodo statico DateTime.Parse(String) o DateTimeOffset.Parse(String).

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

Esempio

Nell'esempio il componente millisecondi di un valore DateTime e DateTimeOffset viene visualizzato nella console, sia da solo che incluso in una stringa di data e ora più lunga.

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

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

Il modello di formato fff include gli zeri finali nei millisecondi. Il modello di formato FFF non li visualizza. Nell'esempio riportato di seguito viene illustrata questa differenza.

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      

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

La definizione di un identificatore di formato personalizzato completo che includa il componente millisecondi di una data e ora pone il problema di definire un formato specificato a livello di codice (hard-coded) che potrebbe non corrispondere alla disposizione degli elementi relativi all'ora specificata dalle impostazioni cultura correnti dell'applicazione. Un'alternativa migliore consiste nel recuperare uno dei modelli di visualizzazione della data/ora definiti dall'oggetto DateTimeFormatInfo delle impostazioni cultura correnti e modificarlo in modo da includere i millisecondi. Nell'esempio viene illustrato anche questo tipo di approccio. Viene recuperato il modello di data e ora completo delle impostazioni cultura correnti dalla proprietà DateTimeFormatInfo.FullDateTimePattern e viene quindi inserito il modello personalizzato .ffff dopo il modello dei secondi. Notare che nell'esempio viene utilizzata un'espressione regolare per eseguire questa operazione in una sola chiamata al metodo.

È anche possibile utilizzare un identificatore di formato personalizzato per visualizzare una parte frazionaria di secondi diversa dai millisecondi. L'identificatore di formato personalizzato f o F consente di visualizzare ad esempio 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. Tali identificatori di formato vengono utilizzati nell'esempio riportato di seguito.

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

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
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 di sistema. In Windows NT 3.5 e versioni successive e nei sistemi operativi Windows Vista la risoluzione dell'orologio è di circa 10-15 millisecondi.

Compilazione del codice

Compilare il codice alla riga di comando utilizzando csc.exe o vb.exe. Per compilare il codice in Visual Studio, inserirlo in un modello di progetto di applicazione console.

Vedere anche

Concetti

Stringhe di formato data e ora personalizzate

Riferimenti

DateTimeFormatInfo