Holen Sie sich die aktuelle Uhrzeit in Millisekunden in C#
- Datum und Uhrzeit in der Programmierung
-
Millisekunden in
C# -
Codierungsbeispiele mit Millisekunden in
C#
In diesem Artikel erfahren Sie, wie Sie die aktuelle Zeit in Millisekunden erhalten. Wir werden das Datum und die Uhrzeit bei der Programmierung besprechen, einschließlich des Systemdatums und der Systemzeit.
Als nächstes werden wir Möglichkeiten diskutieren, Millisekunden zu erhalten. Abschließend werden wir einige Programmierbeispiele mit Millisekunden besprechen.
Datum und Uhrzeit in der Programmierung
Datum und Uhrzeit können Teil vieler Entitäten sein. Viele Transaktionen erfordern ein aktuelles Datum und eine aktuelle Uhrzeit.
Zum Beispiel Verkauf, Kauf, Beitritt, Rückgabe, Ausgabe usw. In vielen Programmen benötigen wir Vergleiche und Berechnungen für Datum und Uhrzeit.
Wir können viele Beispiele spezifizieren, wie das Herausfinden hochrangiger Mitglieder, Tage zwischen Ausgabe und Rückgabe, die Zeit zwischen einigen Aktivitäten wie Bestellung und Lieferung, die Zeit zwischen Start und Linienüberquerung bei einem Rennen, um die Tippgeschwindigkeit zu finden usw.
Jeder Computer hat eine Systemuhr, die aktiv bleibt, auch wenn wir unsere Computer ausschalten. Fast jede Programmiersprache bietet eine Methode, um auf Systemdaten und -zeit zuzugreifen.
Heutzutage stellen viele Server auf der ganzen Welt eine API bereit, um Daten und Zeiten mit unserem Code abzurufen.
Die meisten höheren Programmiersprachen bieten ein einzelnes Objekt mit Datum und Uhrzeit; normalerweise wird es als jetzt bezeichnet. In ähnlicher Weise bietet C# verschiedene Möglichkeiten, auf Systemdaten und -zeit zuzugreifen.
Siehe ein Beispiel:
using System;
class Test {
static void Main() {
DateTime date_time = DateTime.Now;
Console.WriteLine("Welcome, the current date and time is: " +
date_time.ToString("MM/dd/yyyy HH:mm:ss"));
}
}
Ausgang:
Welcome, the current date and time is: 11/05/2022 07:49:27
Wenn Sie Ideen zu Datum und Uhrzeit erhalten, werden wir als Nächstes Möglichkeiten erörtern, Millisekunden in C# zu erhalten.
Millisekunden in C#
In C# gibt es eine DateTime-Struktur des System namespace, die den Zeitpunkt bereitstellt, d. h. meistens Datum und Uhrzeit eines Tages. Mithilfe eines Konstruktors können Sie das Objekt initialisieren, indem Sie einen Datums-/Uhrzeitwert zuweisen oder es anhand seiner Zeichenfolgendarstellung analysieren.
Es gibt verschiedene Möglichkeiten, die Zeit in Millisekunden darzustellen; Wir werden einige davon besprechen.
Verwendung der Eigenschaft Millisekunde
Die DateTime-Struktur stellt eine Millisekunde-Eigenschaft bereit, durch die wir die Komponente von Millisekunden für ein bestimmtes Datum erhalten können. Zum Beispiel:
using System;
class Test {
static void Main() {
DateTime date_time = DateTime.Now;
int ms = date_time.Millisecond;
Console.WriteLine("The current time is:" + date_time.ToString());
Console.WriteLine("The current time in milliseconds is: " + ms.ToString());
}
}
Im obigen Beispiel können wir sehen, dass das Objekt date_time mit dem aktuellen Datum und der Uhrzeit initialisiert wurde, d. h. now, das mit der Eigenschaft millisekunde verwendet wird. Diese Eigenschaft gibt einen ganzzahligen Wert in Millisekunden der aktuellen Zeit zurück.
Ausgang:
The current time is:11/05/2022 04:17:00
The current time in milliseconds is: 736
Zu Demonstrationszwecken haben wir ein Objekt mit aktuellem Datum und Uhrzeit erstellt. Hier ist eine weitere Methode, um Millisekunden aus dem Objekt date_time zu extrahieren.
Hier ist der erste Parameter das Jahr, der zweite Parameter der Monat und der dritte Parameter der Tag.
Ebenso ist der vierte Parameter Stunden, der fünfte Minuten, der sechste Sekunden und der letzte Millisekunden.
DateTime date_time = new DateTime(2022, 11, 4, 9, 20, 30, 120);
Console.WriteLine("Milliseconds: {0:fff}", date_time);
In der zweiten Zeile des Codes geben wir einen Formatbezeichner an, um Millisekunden aus dem Wert date_time zu erhalten. Um Details zu Formatbezeichnern zu lesen, klicken Sie hier.
Ausgang:
Milliseconds: 120
Verwenden der Datums-Zeit-Analyse
Wir können die Zeichenfolgendarstellung von Datum und Uhrzeit in ein DateTime-Objekt umwandeln, indem wir die statische Methode Parse derselben Klasse aufrufen. Wir können den Datumszeitwert auch erhalten, indem wir die statische Parse-Methode von DateTimeOffset aufrufen.
Als nächstes verwenden wir einen Formatbezeichner (bereits besprochen), um Millisekunden zu erhalten. Siehe Code:
using System;
class Test {
static void Main() {
string date_time_string = "10/23/2022 9:22:50.125 AM";
DateTime date_time = DateTime.Parse(date_time_string);
DateTimeOffset date_value = DateTimeOffset.Parse(date_time_string);
Console.WriteLine("Time in Milliseconds: {0}", date_time.ToString("fff"));
Console.WriteLine("\nTime in Milliseconds: {0}", date_value.ToString("fff"));
}
}
Im obigen Code können Sie sehen, dass wir in der Parsing-Methode eine Zeichenfolgendarstellung von Datum und Uhrzeit verwendet haben, die sie automatisch in die entsprechende Datums- und Uhrzeit umwandelt.
Ausgang:
Time in Milliseconds: 125
Time in Milliseconds: 125
Verwenden der Unix-Zeitmethode
Der bequemste Weg, um die Zeit in Millisekunden zu erhalten, ist die Verwendung eines Unix-Zeitstempels. Dieser Zeitstempel gibt mehrere Sekunden zurück, die seit 00:00:00 UTC (Koordinierte Weltzeit) am Januar 1970 vergangen sind, ohne Schaltsekunden.
Die C#-Methode ToUnixTimeMilliseconds wird verwendet, um die Zeit in Millisekunden abzurufen. Zum Beispiel:
DateTimeOffset date = DateTimeOffset.UtcNow;
long milliseconds = date.ToUnixTimeMilliseconds();
Console.WriteLine(milliseconds);
Ausgang:
1667624911885
Wir haben den gleichen Code nach ungefähr 13 Minuten und einigen Sekunden ausgeführt und den Wert erhalten:
1667625703243
Die Differenz ist 791358; Wenn wir dies durch 1000 Millisekunden teilen, erhalten wir 791358 Sekunden. Wenn wir weiter durch 60 Sekunden dividieren, erhalten wir 13.1893 Minuten.
Wir wollen zeigen, dass diese Methode keinen konstanten Wert zurückgibt; Stattdessen werden die seit Januar 1970 verstrichenen Sekunden zurückgegeben.
Zweitens können wir mit dieser Methode die Differenz der Werte verwenden, um Millisekunden in einigen Perioden zu messen.
Benutzerdefinierter Millisekunden-Zeitstempel
Sie können Ihre Zeit auch mit der Eigenschaft Ticks in C# messen. Der Wertebereich von Ticks liegt zwischen minValue und maxValue.
Das folgende Beispiel zeigt die Verwendung von Ticks, um die Zeit in Millisekunden zu erhalten.
long timeInMilliseconds = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
Console.WriteLine(timeInMilliseconds);
Ausgang:
63803225681236
Verwendung der Klasse Stoppuhr
Die Klasse Stopwatch in C# wird verwendet, um die Häufigkeit der Aufgabe im Programm zu messen. Er misst die verstrichene Zeit und ist hilfreich bei der Code-Optimierung.
Mit der Klasse Stopwatch können Sie die Zeit in Millisekunden berechnen. Zum Beispiel:
using System;
using System.Threading;
using System.Diagnostics;
class Test {
static void Main() {
Stopwatch st = new Stopwatch();
st.Start();
Thread.Sleep(1000);
st.Stop();
Console.WriteLine("Time elapsed in Milliseconds: {0}", st.ElapsedMilliseconds);
}
}
Hier verwenden wir die Klasse Stopwatch aus System.Diagnostics. Zu Demonstrationszwecken müssen wir die Stoppuhr starten und nach einer Sekunde stoppen.
Dazwischen können wir jede gewünschte Aufgabe erledigen. Hier haben wir absichtlich die Methode Sleep der Klasse Thread aus dem System.Threading aufgerufen.
Die Sleep-Funktion schafft Zeit zwischen den start/stop-Methoden. Schließlich drucken wir die Eigenschaft ElapsedMilliseconds aus, die die Zeit darstellt, die zwischen Start und Stopp vergangen ist.
Ausgang:
Time elapsed in Milliseconds: 1000
Die Ausgabe zeigt die Zeit, die von der Sleep-Methode benötigt wird. Wir können dies erneut überprüfen, indem wir die Zeit in der Methode Sleep erhöhen. Als Nächstes werden wir einige Codierungsbeispiele mit Millisekunden besprechen.
Codierungsbeispiele mit Millisekunden in C#
Wir haben ein paar Codierungsbeispiele mit Millisekunden in unserem Programm.
Beispiel 1
Zuerst haben wir ein Beispiel für die Berechnung der Zeit, die der Benutzer tippt. Hier haben wir den Code:
using System;
using System.Threading;
using System.Diagnostics;
class Test {
static void Main() {
Stopwatch st = new Stopwatch();
Console.WriteLine("Start typing without using enter key");
st.Start();
Console.ReadLine();
st.Stop();
Console.WriteLine("You have typed for {0}", st.ElapsedMilliseconds / 1000 + " seconds");
}
}
Dieser Code nimmt Eingaben vom Benutzer zwischen den Methoden start und stop entgegen. Im Allgemeinen nehmen wir Benutzereingaben in eine Variable auf, während wir nur versuchen, zwischen der start- und Stopp-Funktion der Stoppuhr etwas Zeit zu verstreichen.
In der letzten Zeile berechnen wir die Anzahl der Sekunden, indem wir die verstrichenen Millisekunden durch 1000 teilen. Ein Beispiellauf dieses Codes ist:
Start typing without using enter key
I am just typing and typing and typing
You have typed for 15 seconds
Die erste Zeile dieser Ausgabe ist eine Nachricht an den Benutzer. In der zweiten Zeile gibt der Benutzer Text ein, bevor die Enter-Taste gedrückt wird, und die letzte Zeile der Ausgabe zeigt die verstrichene Zeit in Sekunden.
Beispiel 2
In diesem Beispiel berechnen wir die Zeit zum Sortieren eines Arrays. Wir haben eine Array-Größe von 10000000 deklariert und die Funktion sort aufgerufen, um das Array zu sortieren.
using System;
using System.Threading;
using System.Diagnostics;
class Array_Sort {
public static void Main() {
Random rn = new Random();
int[] arr = new int[10000000];
for (int i = 0; i < 1000000; i++) arr[i] = rn.Next(0, 50000);
Stopwatch st = new Stopwatch();
st.Start();
Array.Sort(arr);
st.Stop();
Console.WriteLine("Sorting time: {0}", st.ElapsedMilliseconds + " milliseconds");
}
}
Hier haben wir das Array zufällig initialisiert. Wir rufen die Bibliotheksfunktion sort auf, um das Array zu sortieren.
Der Funktionsaufruf liegt zwischen den Funktionen start und stop.
In der letzten Zeile wird die Zeit zwischen Start und Stop, Sortierzeit, in Millisekunden ausgedruckt.
Ausgang:
Sorting time: 2227 milliseconds
Beispiel 3
Das dritte Beispiel demonstriert die Verwendung von Millisekunden bei der Nachverfolgung der Auftragsbearbeitungszeit. In der Praxis haben wir dafür einen formalen Weg; Der Supervisor gibt den Schlüssel jedoch ein, wenn die Bestellung an den Kunden geliefert wird.
Hier berechnen wir die Differenz zwischen Auftragserteilung und Lieferzeit.
using System;
class Order_Track {
public static void Main() {
DateTimeOffset date = DateTimeOffset.UtcNow;
DateTime date_time1 = DateTime.Now;
long order_placed_time = date_time1.Millisecond;
Console.WriteLine("Press Yes, when order is delivered");
Console.ReadLine();
DateTime date_time2 = DateTime.Now;
long order_deliver_time = date_time2.Millisecond;
long difference = order_deliver_time - order_placed_time;
Console.WriteLine("Order process time:" + difference + " milliseconds");
}
}
In der dritten Hauptzeile haben wir die Systemzeit genommen und in der Variable order_placed_time gespeichert.
Als nächstes haben wir eine Nachricht für einen Vorgesetzten oder eine zuständige Behörde, um den Schlüssel einzugeben, wenn die Bestellung geliefert wird. Nach der Eingabe haben wir die Systemzeit erneut erfasst.
In der vorherigen Zeile drucken wir dieses Mal. Schließlich berechnen wir in der vorletzten Zeile die Differenz zwischen beiden Zeiten.
Ausgang:
Press Yes, when order is delivered
Order process time:536 milliseconds
In diesem Artikel haben wir Datum und Uhrzeit umfassend betrachtet. Wir haben mehrere Möglichkeiten besprochen, Millisekunden in C# zu erhalten.
Am Ende haben wir einige Beispiele für die Anwendung von Millisekunden gesehen.