Ist für die CLR ein DateTime-Objekt mit hoher Auflösung (Mikrosekunde, Nanosekunde) verfügbar?

Habe ich ein instrument, das speichert timestamps im Mikrosekunden-Ebene, und ich brauche, um zu speichern diese Zeitstempel als Teil der Sammlung von Informationen aus dem instrument. Beachten Sie, dass ich tun nicht müssen generieren von Zeitstempeln; diese Zeitstempel sind pre-generiert durch das Gerät selbst mit einem hochauflösenden real-time operating system. Analyse aus diesen Werten ist nicht ein Problem — Sie werden gespeichert, mit einem standard-format in der UTC-Zeit. Ursprünglich wollte ich mit der C# DateTime-Struktur kann nur speichern Zeitstempel bis Millisekunden-Auflösung.

Ist es ein anderes Objekt geliefert mit .NET oder ein gemeinsamer C# - Bibliothek, die unterstützt micro - und (idealerweise) Nanosekunden-Auflösung Zeitstempel, oder bin ich da zu Rollen?

InformationsquelleAutor der Frage Robert P | 2011-03-18

  1. 11

    Könnten Sie in der Lage sein zu verwenden DateTime nachdem alle. DateTime.Ticks' Auflösung von 100 Nanosekunden. Sie können die Zecken mit DateTime.AddTicks.

    InformationsquelleAutor der Antwort steinar

  2. 10

    Blick auf die Antworten, und die DateTime.Ticks-Eigenschaft, ist es möglich zu berechnen Mikrosekunden und Nanosekunden von den gegebenen Werten. Als Ergebnis, ich habe diese extension-Methode der Klasse zu tun. (Leider, ich glaube nicht, dass ich in der Lage, es zu benutzen gegeben, einige andere Anforderungen, aber andere Leute finden es vielleicht hilfreich.)

    ///<summary>
///Extension methods for accessing Microseconds and Nanoseconds of a
///DateTime object.
///</summary>
public static class DateTimeExtensionMethods
{
   ///<summary>
   ///The number of ticks per microsecond.
   ///</summary>
   public const int TicksPerMicrosecond = 10;
   ///<summary>
   ///The number of ticks per Nanosecond.
   ///</summary>
   public const int NanosecondsPerTick = 100;

   ///<summary>
   ///Gets the microsecond fraction of a DateTime.
   ///</summary>
   ///<param name="self"></param>
   ///<returns></returns>
   public static int Microseconds(this DateTime self)
   {
      return (int)Math.Floor(
         (self.Ticks 
         % TimeSpan.TicksPerMillisecond )
         / (double)TicksPerMicrosecond);
   }
   ///<summary>
   ///Gets the Nanosecond fraction of a DateTime.  Note that the DateTime
   ///object can only store nanoseconds at resolution of 100 nanoseconds.
   ///</summary>
   ///<param name="self">The DateTime object.</param>
   ///<returns>the number of Nanoseconds.</returns>
   public static int Nanoseconds(this DateTime self)
   {
      return (int)(self.Ticks % TimeSpan.TicksPerMillisecond % TicksPerMicrosecond)
         * NanosecondsPerTick;
   }
   ///<summary>
   ///Adds a number of microseconds to this DateTime object.
   ///</summary>
   ///<param name="self">The DateTime object.</param>
   ///<param name="microseconds">The number of milliseconds to add.</param>
   public static DateTime AddMicroseconds(this DateTime self, int microseconds)
   {
      return self.AddTicks(microseconds * TicksPerMicrosecond);
   }
   ///<summary>
   ///Adds a number of nanoseconds to this DateTime object.  Note: this
   ///object only stores nanoseconds of resolutions of 100 seconds.
   ///Any nanoseconds passed in lower than that will be rounded using
   ///the default rounding algorithm in Math.Round().
   ///</summary>
   ///<param name="self">The DateTime object.</param>
   ///<param name="nanoseconds">The number of nanoseconds to add.</param>
   public static DateTime AddNanoseconds(this DateTime self, int nanoseconds)
   {
      return self.AddTicks((int)Math.Round(nanoseconds / (double)NanosecondsPerTick));
   }
}

    Dieser noch nicht, können Sie die Mikrosekunden oder Nanosekunden nach der Erstellung, aber Sie können Hinzugefügt werden, kurz nach. Es ist auch nicht zu geben, die Auflösung, die besser als das, was ein DateTime kann (zB 1/10 einer Millisekunde aka 100-Nanosekunden-Auflösung).

    DateTime time = new DateTime(year, month, day, hour, min, sec, msec);
time = time.AddMicroseconds(microseconds);
time = time.AddNanoseconds(nanoseconds); # note: rounds if not enough added

    Ich hoffe, dass dies funktioniert für jemand anderes!

    InformationsquelleAutor der Antwort Robert P

  3. 4

    Wenn ich wirklich gebraucht, mehr Genauigkeit, als die 100 ns Auflösung zur Verfügung gestellt von DateTime würde ich erwägen, eine Struktur, die enthält eine DateTime und ein integer-Wert:

    public struct HiResDateTime
{
    public HiResDateTime(DateTime dateTime, int nanoseconds)
    {
        if (nanoSeconds < 0 || nanoSeconds > 99) 
            throw new ArgumentOutOfRangeException(...);
        DateTime = dateTime;
        Nanoseconds = nanoseconds;
    }

    ... possibly other constructors including one that takes a timestamp parameter
    ... in the format provided by the instruments.

    public DateTime DateTime { get; private set; }
    public int Nanoseconds { get; private set; }

    ... implementation ...
}

    Dann umsetzen, was nötig ist, zum Beispiel:

    • Vergleich (DateTime zuerst, dann Nanoseconds)
    • ToString() z.B. format DateTime in 100 ns Genauigkeit hängen Nanosekunden.
    • Konvertierung zu/von DateTime
    • Addieren/subtrahieren (vielleicht einen ähnlichen HiResTimeSpan)
      ... usw. ...

    InformationsquelleAutor der Antwort Joe

  4. 1

    Bin ich zu kämpfen mit diesem gleichen Problem, ich habe ein Projekt, wo ich Pikosekunden-Auflösung Zeitstempel. Die Quelle meiner Daten ist im "time_t" - format, d.h. Sekunden seit epoch + Pikosekunden + UTC-Offset.

    Die beste Lösung, die ich gefunden habe, ist die Arbeit mit "dezimal-Sekunden seit der Epoche in UTC", wie meine Zeit-format intern, und nur mit DateTime als pretty-print-Objekt zu extrahieren locale/Formatierung bis zu 1 s Auflösung, und dann manuell Bearbeiten die Zeichenfolge zu zählen Sekundenbruchteile.

    InformationsquelleAutor der Antwort Chuu

  5. 0

    Könnte Sie wahrscheinlich Rollen Sie Ihre eigenen, in verschiedener Weise.

    1.) Erstellen Sie eine Struktur mit System.Dezimal Feld als "backing store".

    2.) Erstellen Sie eine Struktur mit System.Numerik.BigInteger als Unterlage.

    Wrap-Methoden zu verwenden, System.DateTime für die komfortable "Teilen" (Jahr, Monat, Tag,...)
    Ihre eigenen Nanonsecond, Pikosekunden, Femtosekunden -, etc., Eigenschaften und Methoden.

    FYI:

    DateTime.MaxValue.Zecken : 3,155,378,975,999,999,999

    Dezimal.MaxValue : 79,228,162,514,264,337,593,543,950,335

    BigInteger : Beliebig Große!

    InformationsquelleAutor der Antwort Ben Stabile

Schreibe einen Kommentar