C#でミリ秒を扱う方法｜DateTime・TimeSpan・Stopwatchでの取得・変換・計測をわかりやすく解説

はじめに

C#で日時や処理時間を扱っていると、「ミリ秒を取得したい」「ミリ秒付きでログを出したい」「処理時間をミリ秒単位で計測したい」といった場面がよくあります。

しかし、C#にはミリ秒に関係するプロパティやメソッドが複数あります。たとえば、DateTime.Now.Millisecond、TimeSpan.Milliseconds、TimeSpan.TotalMilliseconds、Stopwatch.ElapsedMilliseconds などです。

名前が似ているため混同しやすいですが、それぞれ意味が異なります。特に、Millisecond や Milliseconds は「総ミリ秒」ではなく、秒や時間の一部としてのミリ秒部分を表す点に注意が必要です。

この記事では、C#でミリ秒を扱う方法を、DateTime、TimeSpan、Stopwatch、Unix時間、加算・減算、待機処理まで含めてわかりやすく解説します。

1. C#で扱う「ミリ秒」とは

1-1. ミリ秒は1秒の1000分の1を表す単位

ミリ秒は、1秒を1000分の1に分けた時間単位です。

C#
1秒 = 1000ミリ秒
1ミリ秒 = 0.001秒

C#では、日時や時間差、処理時間、待機時間などを扱うときにミリ秒がよく使われます。

たとえば、次のような場面です。

C#
// 500ミリ秒待機する
Thread.Sleep(500);

// 1.5秒をミリ秒で表す
int milliseconds = 1500;

ミリ秒は非常に短い時間を表す単位ですが、アプリケーション開発ではログ、タイマー、API連携、パフォーマンス計測などで頻繁に使われます。

1-2. C#でミリ秒を扱う主な場面

C#でミリ秒を扱う主な場面は、次のとおりです。

C#
// 現在時刻のミリ秒部分を取得する
int millisecond = DateTime.Now.Millisecond;

// 処理時間をミリ秒で計測する
Stopwatch stopwatch = Stopwatch.StartNew();
// 何らかの処理
stopwatch.Stop();

long elapsed = stopwatch.ElapsedMilliseconds;

// 時間差をミリ秒に変換する
TimeSpan span = DateTime.Now - DateTime.Today;
double totalMilliseconds = span.TotalMilliseconds;

// Unix時間をミリ秒で取得する
long unixMilliseconds = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

同じ「ミリ秒」でも、何を知りたいかによって使うクラスやプロパティが変わります。

現在時刻のミリ秒部分を知りたい場合は DateTime、時間差をミリ秒に変換したい場合は TimeSpan、処理時間を正確に計測したい場合は Stopwatch を使うのが基本です。

1-3. DateTime・TimeSpan・Stopwatchの使い分け

C#でミリ秒を扱うときは、目的に応じて次のように使い分けます。

たとえば、現在時刻を表示するために Stopwatch を使うことはありません。また、処理時間の計測に DateTime.Now を使うよりも、通常は Stopwatch を使う方が適しています。

1-4. Millisecond・TotalMilliseconds・ElapsedMillisecondsの違い

C#でミリ秒を扱うときに特に混同しやすいのが、次の3つです。

たとえば、DateTime.Now.Millisecond は「現在時刻の総ミリ秒」ではありません。

C#
DateTime now = DateTime.Now;

Console.WriteLine(now.Millisecond);

このコードで取得できるのは、現在時刻の「秒未満のミリ秒部分」です。値の範囲は 0 から 999 です。

一方で、時間差全体をミリ秒で取得したい場合は TimeSpan.TotalMilliseconds を使います。

C#
DateTime start = DateTime.Now;
DateTime end = start.AddSeconds(3);

TimeSpan diff = end - start;

Console.WriteLine(diff.TotalMilliseconds); // 3000

処理時間をミリ秒単位で計測したい場合は、Stopwatch.ElapsedMilliseconds を使います。

C#
Stopwatch sw = Stopwatch.StartNew();

Thread.Sleep(1000);

sw.Stop();

Console.WriteLine(sw.ElapsedMilliseconds); // 約1000

2. DateTimeでミリ秒を取得する方法

2-1. 現在時刻のミリ秒を取得する基本コード

C#で現在時刻のミリ秒部分を取得するには、DateTime.Now.Millisecond を使います。

C#
DateTime now = DateTime.Now;

int millisecond = now.Millisecond;

Console.WriteLine(millisecond);

実行結果の例は次のようになります。

347

この値は、現在時刻の「ミリ秒部分」です。

たとえば現在時刻が 2026/06/18 10:15:30.347 の場合、Millisecond は 347 になります。

2-2. DateTime.Now.Millisecondの意味

DateTime.Now.Millisecond は、ローカル時刻におけるミリ秒部分を返します。

C#
DateTime now = DateTime.Now;

Console.WriteLine(now.ToString("yyyy/MM/dd HH:mm:ss.fff"));
Console.WriteLine(now.Millisecond);

実行結果の例です。

2026/06/18 10:15:30.347
347

ここで重要なのは、Millisecond が返すのは「現在時刻を何らかの基準から数えた総ミリ秒」ではないという点です。

10:15:30.347 の 347 の部分だけを取得します。

つまり、次のような意味です。

秒の小数部分 = 347ミリ秒

「今日の0時からの経過ミリ秒」や「1970年1月1日からの経過ミリ秒」を取得したい場合は、別の方法を使う必要があります。

2-3. DateTime.UtcNowでUTC時刻のミリ秒を取得する

UTC時刻のミリ秒部分を取得したい場合は、DateTime.UtcNow.Millisecond を使います。

C#
DateTime utcNow = DateTime.UtcNow;

int millisecond = utcNow.Millisecond;

Console.WriteLine(utcNow.ToString("yyyy/MM/dd HH:mm:ss.fff"));
Console.WriteLine(millisecond);

DateTime.Now はローカル時刻、DateTime.UtcNow はUTC時刻を表します。

C#
DateTime local = DateTime.Now;
DateTime utc = DateTime.UtcNow;

Console.WriteLine(local.ToString("yyyy/MM/dd HH:mm:ss.fff"));
Console.WriteLine(utc.ToString("yyyy/MM/dd HH:mm:ss.fff"));

API連携やサーバー間の時刻管理では、ローカル時刻よりもUTCを使う方が扱いやすい場合があります。

特に、タイムゾーンをまたぐシステムでは、ローカル時刻のまま保存すると時刻の解釈がずれる可能性があります。

2-4. Millisecondプロパティで取得できる値の範囲

DateTime.Millisecond で取得できる値の範囲は、0 から 999 です。

C#
DateTime now = DateTime.Now;

int ms = now.Millisecond;

Console.WriteLine(ms); // 0～999

これは、1秒が1000ミリ秒で構成されているためです。

たとえば次のような時刻では、Millisecond の値はそれぞれ次のようになります。

Millisecond は秒の中の一部分なので、1000以上の値にはなりません。

2-5. 「現在時刻をミリ秒単位で取得」と混同しやすいポイント

「現在時刻をミリ秒単位で取得したい」という表現には、複数の意味があります。

たとえば、次のように目的が異なります。

たとえば、Unixミリ秒を取得したい場合に DateTime.Now.Millisecond を使うのは誤りです。

C#
// Unixミリ秒ではない
int wrong = DateTime.Now.Millisecond;

// Unixミリ秒
long unixMs = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

DateTime.Now.Millisecond は 0 から 999 の範囲しか返さないため、現在時刻を表す一意な数値としては使えません。

3. DateTimeをミリ秒付きで表示・フォーマットする方法

3-1. yyyy/MM/dd HH:mm:ss.fffでミリ秒を表示する

DateTime をミリ秒付きで表示したい場合は、ToString にフォーマット文字列を指定します。

C#
DateTime now = DateTime.Now;

string text = now.ToString("yyyy/MM/dd HH:mm:ss.fff");

Console.WriteLine(text);

実行結果の例です。

2026/06/18 10:15:30.347

フォーマットの意味は次のとおりです。

ログ出力では、秒単位だけだと処理の順序や時間差がわかりにくいことがあります。そのため、ミリ秒付きのフォーマットがよく使われます。

3-2. fff・ffffff・fffffffの違い

C#の日時フォーマットでは、f の数によって秒未満の桁数を指定できます。

ミリ秒は3桁なので、通常は fff を使います。

C#
DateTime now = DateTime.Now;

Console.WriteLine(now.ToString("HH:mm:ss.f"));
Console.WriteLine(now.ToString("HH:mm:ss.ff"));
Console.WriteLine(now.ToString("HH:mm:ss.fff"));
Console.WriteLine(now.ToString("HH:mm:ss.ffffff"));
Console.WriteLine(now.ToString("HH:mm:ss.fffffff"));

実行結果の例です。

10:15:30.3
10:15:30.34
10:15:30.347
10:15:30.347000
10:15:30.3470000

DateTime は内部的にミリ秒より細かい単位も持てますが、OSや取得方法によって実際の時刻精度は異なります。単に fffffff で表示したからといって、必ず高精度な現在時刻が取得できるわけではありません。

3-3. ミリ秒付きの文字列をDateTimeに変換する

ミリ秒付きの文字列を DateTime に変換するには、DateTime.Parse または DateTime.ParseExact を使います。

まず、単純に変換できる形式であれば Parse を使えます。

C#
string text = "2026/06/18 10:15:30.347";

DateTime dt = DateTime.Parse(text);

Console.WriteLine(dt.ToString("yyyy/MM/dd HH:mm:ss.fff"));

実行結果です。

2026/06/18 10:15:30.347

ただし、文字列の形式が固定されている場合は、ParseExact を使った方が意図が明確になります。

3-4. Parse・ParseExactを使った変換例

DateTime.Parse は、比較的柔軟に日時文字列を解釈します。

C#
string text = "2026/06/18 10:15:30.347";

DateTime dt = DateTime.Parse(text);

Console.WriteLine(dt);

一方、DateTime.ParseExact は指定したフォーマットに完全一致する文字列を変換します。

C#
using System.Globalization;

string text = "2026/06/18 10:15:30.347";
string format = "yyyy/MM/dd HH:mm:ss.fff";

DateTime dt = DateTime.ParseExact(
    text,
    format,
    CultureInfo.InvariantCulture
);

Console.WriteLine(dt.ToString(format));

ログや外部ファイルから日時を読み込む場合、入力形式が固定されているなら ParseExact が便利です。

たとえば、次のようにハイフン区切りの日時を扱うこともできます。

C#
using System.Globalization;

string text = "2026-06-18 10:15:30.347";
string format = "yyyy-MM-dd HH:mm:ss.fff";

DateTime dt = DateTime.ParseExact(
    text,
    format,
    CultureInfo.InvariantCulture
);

Console.WriteLine(dt.ToString("yyyy/MM/dd HH:mm:ss.fff"));

3-5. ログ出力で使いやすいミリ秒付きフォーマット

ログ出力では、日付と時刻をミリ秒付きで出力すると、処理の流れを追いやすくなります。

C#
DateTime now = DateTime.Now;

Console.WriteLine($"[{now:yyyy-MM-dd HH:mm:ss.fff}] 処理を開始しました");

実行結果の例です。

[2026-06-18 10:15:30.347] 処理を開始しました

ログでは、次のようなフォーマットがよく使われます。

C#
DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")

ファイル名に日時を含める場合は、: や / が使えない環境もあるため、次のような形式が便利です。

C#
string fileName = DateTime.Now.ToString("yyyyMMdd_HHmmss_fff") + ".log";

Console.WriteLine(fileName);

実行結果の例です。

20260618_101530_347.log

4. TimeSpanで時間差をミリ秒に変換する方法

4-1. TimeSpanとは

TimeSpan は、時間の長さや時間差を表す構造体です。

DateTime が「ある時点」を表すのに対して、TimeSpan は「期間」を表します。

C#
DateTime start = new DateTime(2026, 6, 18, 10, 0, 0);
DateTime end = new DateTime(2026, 6, 18, 10, 0, 5);

TimeSpan diff = end - start;

Console.WriteLine(diff);

実行結果です。

00:00:05

この例では、start と end の差は5秒です。

TimeSpan を使うと、この時間差を秒、分、時間、ミリ秒などに変換できます。

C#
Console.WriteLine(diff.TotalSeconds);      // 5
Console.WriteLine(diff.TotalMilliseconds); // 5000

4-2. TimeSpan.MillisecondsとTotalMillisecondsの違い

TimeSpan でミリ秒を扱うときに最も注意したいのが、Milliseconds と TotalMilliseconds の違いです。

C#
TimeSpan span = TimeSpan.FromSeconds(1.5);

Console.WriteLine(span.Milliseconds);
Console.WriteLine(span.TotalMilliseconds);

実行結果です。

500
1500

Milliseconds は、時間差の中の「ミリ秒部分」だけを返します。

一方、TotalMilliseconds は、時間差全体をミリ秒に換算した値を返します。

たとえば、1.5秒は1500ミリ秒ですが、Milliseconds は秒未満の部分だけを見るため 500 になります。

通常、時間差をミリ秒で取得したい場合は TotalMilliseconds を使います。

4-3. 日時の差分をミリ秒で取得する

2つの DateTime の差をミリ秒で取得するには、引き算で TimeSpan を作り、TotalMilliseconds を参照します。

C#
DateTime start = DateTime.Now;

// 何らかの処理
Thread.Sleep(1200);

DateTime end = DateTime.Now;

TimeSpan diff = end - start;

Console.WriteLine(diff.TotalMilliseconds);

実行結果の例です。

1203.4567

TotalMilliseconds は double 型なので、小数を含む可能性があります。

整数として扱いたい場合は、必要に応じて丸めます。

C#
double totalMs = diff.TotalMilliseconds;

Console.WriteLine((long)totalMs);              // 小数部分を切り捨て
Console.WriteLine(Math.Round(totalMs));        // 四捨五入
Console.WriteLine(Math.Ceiling(totalMs));      // 切り上げ
Console.WriteLine(Math.Floor(totalMs));        // 切り捨て

ただし、処理時間の計測が目的であれば、DateTime.Now よりも Stopwatch を使う方が適しています。

4-4. ミリ秒からTimeSpanを作成する

ミリ秒から TimeSpan を作成するには、TimeSpan.FromMilliseconds を使います。

C#
TimeSpan span = TimeSpan.FromMilliseconds(1500);

Console.WriteLine(span);
Console.WriteLine(span.TotalSeconds);

実行結果です。

00:00:01.5000000
1.5

FromMilliseconds には double 型の値を渡せます。

C#
TimeSpan span = TimeSpan.FromMilliseconds(123.45);

Console.WriteLine(span.TotalMilliseconds);

TimeSpan を使うと、ミリ秒を秒や分に変換したり、日時に加算したりできます。

C#
DateTime now = DateTime.Now;
TimeSpan wait = TimeSpan.FromMilliseconds(500);

DateTime after = now + wait;

Console.WriteLine(after.ToString("HH:mm:ss.fff"));

4-5. 秒・分・時間とミリ秒を相互変換する

ミリ秒と秒、分、時間は次のように変換できます。

C#
// 秒からミリ秒
double ms1 = TimeSpan.FromSeconds(2).TotalMilliseconds;

// 分からミリ秒
double ms2 = TimeSpan.FromMinutes(1).TotalMilliseconds;

// 時間からミリ秒
double ms3 = TimeSpan.FromHours(1).TotalMilliseconds;

Console.WriteLine(ms1); // 2000
Console.WriteLine(ms2); // 60000
Console.WriteLine(ms3); // 3600000

逆に、ミリ秒を秒、分、時間に変換するには次のようにします。

C#
TimeSpan span = TimeSpan.FromMilliseconds(90000);

Console.WriteLine(span.TotalSeconds); // 90
Console.WriteLine(span.TotalMinutes); // 1.5
Console.WriteLine(span.TotalHours);   // 0.025

単純な計算でも変換できます。

C#
double milliseconds = 90000;

double seconds = milliseconds / 1000;
double minutes = milliseconds / 1000 / 60;
double hours = milliseconds / 1000 / 60 / 60;

Console.WriteLine(seconds);
Console.WriteLine(minutes);
Console.WriteLine(hours);

ただし、C#では TimeSpan を使う方が意味が明確になり、コードも読みやすくなります。

4-6. 小数を含むミリ秒を扱うときの注意点

TimeSpan.TotalMilliseconds は double 型です。

C#
TimeSpan span = TimeSpan.FromTicks(12345);

double ms = span.TotalMilliseconds;

Console.WriteLine(ms);

double は小数を扱える一方で、浮動小数点数の性質上、完全に正確な10進数として表現できない場合があります。

たとえば、表示や比較では注意が必要です。

C#
double ms = TimeSpan.FromMilliseconds(0.1).TotalMilliseconds;

Console.WriteLine(ms);

通常のアプリケーションでは大きな問題にならないことも多いですが、厳密な比較を行う場合は、誤差を考慮します。

C#
double a = TimeSpan.FromMilliseconds(100.1).TotalMilliseconds;
double b = 100.1;

if (Math.Abs(a - b) < 0.0001)
{
    Console.WriteLine("ほぼ等しい");
}

整数のミリ秒だけを扱う場合は、long や int に変換して扱うこともあります。

C#
long milliseconds = (long)Math.Round(span.TotalMilliseconds);

5. Stopwatchで処理時間をミリ秒単位で計測する方法

5-1. Stopwatchを使うべき理由

C#で処理時間をミリ秒単位で計測するなら、基本的には Stopwatch を使います。

DateTime.Now を使って開始時刻と終了時刻の差を取ることもできますが、処理時間の計測には向いていない場合があります。

C#
DateTime start = DateTime.Now;

// 処理
Thread.Sleep(1000);

DateTime end = DateTime.Now;

Console.WriteLine((end - start).TotalMilliseconds);

この方法でも簡単な計測はできますが、システム時刻の変更や時刻精度の影響を受ける可能性があります。

一方、Stopwatch は経過時間の計測を目的としたクラスです。

C#
Stopwatch stopwatch = Stopwatch.StartNew();

// 処理
Thread.Sleep(1000);

stopwatch.Stop();

Console.WriteLine(stopwatch.ElapsedMilliseconds);

パフォーマンス計測、処理時間の確認、ベンチマークなどでは、Stopwatch を使うのが適切です。

5-2. 処理時間をミリ秒で計測する基本コード

Stopwatch を使った基本的な計測コードは次のとおりです。

C#
using System.Diagnostics;

Stopwatch stopwatch = new Stopwatch();

stopwatch.Start();

// 計測したい処理
Thread.Sleep(1200);

stopwatch.Stop();

Console.WriteLine($"{stopwatch.ElapsedMilliseconds} ms");

実行結果の例です。

1204 ms

Stopwatch.StartNew() を使うと、インスタンス作成と開始を同時に行えます。

C#
using System.Diagnostics;

Stopwatch stopwatch = Stopwatch.StartNew();

// 計測したい処理
Thread.Sleep(1200);

stopwatch.Stop();

Console.WriteLine($"{stopwatch.ElapsedMilliseconds} ms");

短く書きたい場合は、StartNew() が便利です。

5-3. ElapsedMillisecondsで経過時間を取得する

ElapsedMilliseconds は、計測開始からの経過時間をミリ秒単位の整数で取得します。

C#
Stopwatch sw = Stopwatch.StartNew();

Thread.Sleep(1500);

sw.Stop();

long elapsedMs = sw.ElapsedMilliseconds;

Console.WriteLine(elapsedMs);

実行結果の例です。

1502

ElapsedMilliseconds の型は long です。

そのため、長時間の計測でも扱いやすいです。

C#
long ms = sw.ElapsedMilliseconds;

処理時間をログに出力する場合にもよく使います。

C#
Console.WriteLine($"処理時間: {sw.ElapsedMilliseconds}ms");

5-4. Elapsed.TotalMillisecondsとの違い

Stopwatch には、ElapsedMilliseconds のほかに Elapsed.TotalMilliseconds もあります。

C#
Stopwatch sw = Stopwatch.StartNew();

Thread.Sleep(1234);

sw.Stop();

Console.WriteLine(sw.ElapsedMilliseconds);
Console.WriteLine(sw.Elapsed.TotalMilliseconds);

実行結果の例です。

1234
1234.5678

違いは次のとおりです。

整数のミリ秒で十分な場合は ElapsedMilliseconds を使います。

より細かい値を確認したい場合は Elapsed.TotalMilliseconds を使います。

C#
double preciseMs = sw.Elapsed.TotalMilliseconds;

ログや画面表示では ElapsedMilliseconds、詳細な測定では Elapsed.TotalMilliseconds という使い分けができます。

5-5. Start・Stop・Restart・Resetの使い方

Stopwatch には、計測を制御するためのメソッドが用意されています。

C#
Stopwatch sw = new Stopwatch();

sw.Start();   // 計測開始
sw.Stop();    // 計測停止
sw.Reset();   // 経過時間を0に戻す
sw.Restart(); // 0に戻して再スタート

基本的な使い方です。

C#
Stopwatch sw = new Stopwatch();

sw.Start();

Thread.Sleep(500);

sw.Stop();

Console.WriteLine(sw.ElapsedMilliseconds);

Stop() 後に再び Start() すると、前回の経過時間に加算されます。

C#
Stopwatch sw = new Stopwatch();

sw.Start();
Thread.Sleep(500);
sw.Stop();

sw.Start();
Thread.Sleep(500);
sw.Stop();

Console.WriteLine(sw.ElapsedMilliseconds); // 約1000

経過時間をリセットしてもう一度計測したい場合は Reset() を使います。

C#
sw.Reset();
sw.Start();

または Restart() を使うと、リセットと開始を同時に行えます。

C#
sw.Restart();

Thread.Sleep(300);

sw.Stop();

Console.WriteLine(sw.ElapsedMilliseconds);

5-6. DateTimeではなくStopwatchを使うべきケース

次のようなケースでは、DateTime ではなく Stopwatch を使うべきです。

C#
// 処理時間を測る
Stopwatch sw = Stopwatch.StartNew();

DoSomething();

sw.Stop();

Console.WriteLine(sw.ElapsedMilliseconds);

具体的には、次のような場面です。

DateTime は日時を表すための型であり、処理時間の計測専用ではありません。

処理時間の計測では、次のように Stopwatch を使うと意図が明確になります。

C#
using System.Diagnostics;

var sw = Stopwatch.StartNew();

for (int i = 0; i < 1000000; i++)
{
    // 計測したい処理
}

sw.Stop();

Console.WriteLine($"Elapsed: {sw.ElapsedMilliseconds} ms");

6. Unix時間をミリ秒で扱う方法

6-1. Unix時間とは

Unix時間とは、1970年1月1日 00:00:00 UTCからの経過時間を表す値です。

一般的には秒単位で表されますが、APIやJavaScriptではミリ秒単位で扱われることも多いです。

Unix秒       : 1970年1月1日からの経過秒
Unixミリ秒   : 1970年1月1日からの経過ミリ秒

JavaScriptの Date.now() は、Unix時間をミリ秒単位で返します。

C#で同じような値を取得したい場合は、DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() を使います。

6-2. 現在時刻をUnixミリ秒で取得する

C#で現在時刻をUnixミリ秒で取得するには、次のように書きます。

C#
long unixMilliseconds = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

Console.WriteLine(unixMilliseconds);

実行結果の例です。

1781754930347

この値は、1970年1月1日 00:00:00 UTCから現在までの経過ミリ秒です。

DateTime.Now.Millisecond とはまったく意味が異なります。

C#
Console.WriteLine(DateTime.Now.Millisecond); // 0～999
Console.WriteLine(DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()); // Unixミリ秒

Unixミリ秒は大きな数値になるため、int ではなく long で扱います。

6-3. DateTimeOffset.ToUnixTimeMillisecondsの使い方

DateTimeOffset.ToUnixTimeMilliseconds() は、DateTimeOffset の値をUnixミリ秒に変換するメソッドです。

C#
DateTimeOffset now = DateTimeOffset.UtcNow;

long unixMs = now.ToUnixTimeMilliseconds();

Console.WriteLine(unixMs);

特定の日時をUnixミリ秒に変換することもできます。

C#
DateTimeOffset date = new DateTimeOffset(
    2026, 6, 18,
    10, 15, 30,
    TimeSpan.Zero
);

long unixMs = date.ToUnixTimeMilliseconds();

Console.WriteLine(unixMs);

TimeSpan.Zero はUTCを表します。

ローカル時刻から変換する場合は、タイムゾーンの扱いに注意が必要です。

C#
DateTimeOffset local = new DateTimeOffset(DateTime.Now);

long unixMs = local.ToUnixTimeMilliseconds();

Console.WriteLine(unixMs);

API連携では、UTC基準のUnixミリ秒を使うことが多いため、基本的には DateTimeOffset.UtcNow を使うとわかりやすいです。

6-4. Unixミリ秒からDateTimeに変換する

Unixミリ秒から日時に変換するには、DateTimeOffset.FromUnixTimeMilliseconds を使います。

C#
long unixMs = 1781754930347;

DateTimeOffset dto = DateTimeOffset.FromUnixTimeMilliseconds(unixMs);

Console.WriteLine(dto);

UTCの DateTime として取得したい場合は、UtcDateTime を使います。

C#
DateTime utcDateTime = DateTimeOffset
    .FromUnixTimeMilliseconds(unixMs)
    .UtcDateTime;

Console.WriteLine(utcDateTime.ToString("yyyy/MM/dd HH:mm:ss.fff"));

ローカル時刻として表示したい場合は、LocalDateTime を使います。

C#
DateTime localDateTime = DateTimeOffset
    .FromUnixTimeMilliseconds(unixMs)
    .LocalDateTime;

Console.WriteLine(localDateTime.ToString("yyyy/MM/dd HH:mm:ss.fff"));

DateTimeOffset のまま扱うこともできます。

C#
DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeMilliseconds(unixMs);

Console.WriteLine(dateTimeOffset.ToString("yyyy/MM/dd HH:mm:ss.fff zzz"));

タイムゾーンを考慮するシステムでは、DateTime よりも DateTimeOffset の方が安全に扱えることがあります。

6-5. API・DB・JavaScript連携でよく使うミリ秒形式

Unixミリ秒は、API、データベース、JavaScriptとの連携でよく使われます。

たとえば、JavaScriptでは次のように現在時刻のUnixミリ秒を取得します。

JavaScript
const now = Date.now();
console.log(now);

C#で同じ形式の値を取得するには、次のようにします。

C#
long now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

Console.WriteLine(now);

JSONで日時をやり取りする場合にも、Unixミリ秒が使われることがあります。

JSON
{
  "createdAt": 1781754930347
}

C#で受け取ったUnixミリ秒を日時に変換する例です。

C#
long createdAt = 1781754930347;

DateTimeOffset createdDate = DateTimeOffset.FromUnixTimeMilliseconds(createdAt);

Console.WriteLine(createdDate.UtcDateTime.ToString("yyyy/MM/dd HH:mm:ss.fff"));

Unixミリ秒を使うと、タイムゾーンに依存しない時刻表現にしやすいというメリットがあります。

ただし、表示するときにはユーザーのローカル時刻に変換するなど、用途に応じた処理が必要です。

7. ミリ秒の加算・減算を行う方法

7-1. DateTime.AddMillisecondsでミリ秒を加算する

DateTime にミリ秒を加算するには、AddMilliseconds を使います。

C#
DateTime now = DateTime.Now;

DateTime after = now.AddMilliseconds(500);

Console.WriteLine(now.ToString("HH:mm:ss.fff"));
Console.WriteLine(after.ToString("HH:mm:ss.fff"));

実行結果の例です。

10:15:30.347
10:15:30.847

AddMilliseconds は、新しい DateTime を返します。

元の DateTime 自体は変更されません。

C#
DateTime now = DateTime.Now;

now.AddMilliseconds(500);

Console.WriteLine(now.ToString("HH:mm:ss.fff"));

このように戻り値を受け取らないと、加算結果は使われません。

正しくは次のように書きます。

C#
DateTime now = DateTime.Now;

now = now.AddMilliseconds(500);

Console.WriteLine(now.ToString("HH:mm:ss.fff"));

7-2. DateTime.AddMillisecondsでミリ秒を減算する

ミリ秒を減算したい場合は、AddMilliseconds に負の値を渡します。

C#
DateTime now = DateTime.Now;

DateTime before = now.AddMilliseconds(-500);

Console.WriteLine(now.ToString("HH:mm:ss.fff"));
Console.WriteLine(before.ToString("HH:mm:ss.fff"));

実行結果の例です。

10:15:30.347
10:15:29.847

1秒以上を減算することもできます。

C#
DateTime now = DateTime.Now;

DateTime before = now.AddMilliseconds(-1500);

Console.WriteLine(before.ToString("HH:mm:ss.fff"));

この場合、1.5秒前の日時になります。

秒や分単位で加算・減算したい場合は、AddSeconds や AddMinutes も使えます。

C#
DateTime after1Second = now.AddSeconds(1);
DateTime after1Minute = now.AddMinutes(1);

ただし、ミリ秒単位で細かく制御したい場合は AddMilliseconds が便利です。

7-3. TimeSpan.FromMillisecondsを使った加算・減算

TimeSpan.FromMilliseconds を使って、ミリ秒を時間間隔として表すこともできます。

C#
DateTime now = DateTime.Now;

TimeSpan span = TimeSpan.FromMilliseconds(500);

DateTime after = now + span;

Console.WriteLine(after.ToString("HH:mm:ss.fff"));

減算する場合は、DateTime から TimeSpan を引きます。

C#
DateTime now = DateTime.Now;

TimeSpan span = TimeSpan.FromMilliseconds(500);

DateTime before = now - span;

Console.WriteLine(before.ToString("HH:mm:ss.fff"));

AddMilliseconds と比べると、TimeSpan を使う方法は「時間間隔」を変数として扱いやすいのが特徴です。

C#
TimeSpan timeout = TimeSpan.FromMilliseconds(3000);

DateTime expireAt = DateTime.Now + timeout;

Console.WriteLine(expireAt.ToString("HH:mm:ss.fff"));

タイムアウト、待機時間、有効期限などを表す場合は、TimeSpan を使うと意味が明確になります。

7-4. タイマー処理や待機時間での活用例

ミリ秒は、タイマー処理や待機時間の指定でよく使われます。

たとえば、一定間隔で処理を実行したい場合です。

C#
using System.Timers;

Timer timer = new Timer(1000); // 1000ミリ秒 = 1秒

timer.Elapsed += (sender, e) =>
{
    Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff"));
};

timer.Start();

Console.ReadLine();

この例では、1秒ごとに現在時刻を表示します。

短い間隔を扱う場合は、値がミリ秒単位であることを明確にするため、変数名に Milliseconds や ms を含めると読みやすくなります。

C#
int intervalMilliseconds = 500;

Timer timer = new Timer(intervalMilliseconds);

TimeSpan を使って定義する方法もあります。

C#
TimeSpan interval = TimeSpan.FromMilliseconds(500);

Console.WriteLine(interval.TotalMilliseconds);

ライブラリやAPIによっては int のミリ秒を要求する場合と、TimeSpan を要求する場合があります。どちらの型を使うべきかは、使用するメソッドに合わせて選びます。

7-5. Thread.Sleep・Task.Delayでミリ秒を指定する方法

C#で一定時間待機するには、Thread.Sleep や Task.Delay を使います。

Thread.Sleep は、現在のスレッドを指定したミリ秒だけ停止します。

C#
Thread.Sleep(1000); // 1000ミリ秒 = 1秒

一方、非同期処理では Task.Delay を使います。

C#
await Task.Delay(1000); // 1000ミリ秒 = 1秒

TimeSpan を渡すこともできます。

C#
await Task.Delay(TimeSpan.FromMilliseconds(500));

非同期メソッドの中では、基本的に Thread.Sleep ではなく Task.Delay を使います。

C#
public async Task ExecuteAsync()
{
    Console.WriteLine("開始");

    await Task.Delay(1000);

    Console.WriteLine("1秒後");
}

Thread.Sleep はスレッドをブロックしますが、Task.Delay は非同期的に待機できます。

そのため、UIアプリやWebアプリでは Task.Delay の方が適していることが多いです。

8. C#でミリ秒を扱うときの注意点

8-1. Millisecondは「総ミリ秒」ではない

C#でミリ秒を扱うとき、最もよくある勘違いが Millisecond を「総ミリ秒」だと思ってしまうことです。

C#
int ms = DateTime.Now.Millisecond;

このコードで取得できるのは、現在時刻のミリ秒部分だけです。

値は 0 から 999 です。

C#
Console.WriteLine(DateTime.Now.Millisecond); // 例: 347

現在時刻をUnixミリ秒で取得したいなら、次のようにします。

C#
long unixMs = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

時間差の総ミリ秒を取得したいなら、TimeSpan.TotalMilliseconds を使います。

C#
TimeSpan span = DateTime.Now - DateTime.Today;

double totalMs = span.TotalMilliseconds;

プロパティ名だけで判断せず、「ミリ秒部分」なのか「全体をミリ秒に換算した値」なのかを確認することが大切です。

8-2. DateTime.Nowは高精度な計測には向かない

DateTime.Now を使って処理時間を計測することもできます。

C#
DateTime start = DateTime.Now;

// 処理
Thread.Sleep(1000);

DateTime end = DateTime.Now;

Console.WriteLine((end - start).TotalMilliseconds);

しかし、高精度な処理時間の計測には DateTime.Now は向いていません。

処理時間を測る目的であれば、Stopwatch を使います。

C#
Stopwatch sw = Stopwatch.StartNew();

// 処理
Thread.Sleep(1000);

sw.Stop();

Console.WriteLine(sw.ElapsedMilliseconds);

DateTime は日時を表すための型であり、経過時間の計測専用ではありません。

現在日時の取得や表示には DateTime、処理時間の計測には Stopwatch という使い分けを意識しましょう。

8-3. OSや環境による時刻精度の違い

DateTime.Now や DateTime.UtcNow で取得できる時刻の精度は、OSや実行環境に影響されることがあります。

たとえば、フォーマットで fffffff を指定すると7桁まで表示できます。

C#
Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.fffffff"));

しかし、表示桁数が多いからといって、実際にその精度で現在時刻が取得できているとは限りません。

10:15:30.3470000

このように、後ろの桁が常に同じような値になることもあります。

短い処理時間を測定する場合や、精度が重要な計測では、Stopwatch を使う方が適しています。

C#
Console.WriteLine(Stopwatch.IsHighResolution);
Console.WriteLine(Stopwatch.Frequency);

Stopwatch.IsHighResolution を確認すると、高分解能パフォーマンスカウンターが使われているかどうかを確認できます。

8-4. long・double・intの型選びに注意する

ミリ秒を扱うときは、型選びにも注意が必要です。

よく使われる型は、int、long、double です。

たとえば、Thread.Sleep に渡す値は int のミリ秒として扱うことが多いです。

C#
int waitMilliseconds = 1000;

Thread.Sleep(waitMilliseconds);

Unixミリ秒は非常に大きな値になるため、int では扱えません。

C#
long unixMs = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

TimeSpan.TotalMilliseconds は double です。

C#
TimeSpan span = TimeSpan.FromSeconds(1.5);

double ms = span.TotalMilliseconds;

必要に応じて、丸めやキャストを行います。

C#
long rounded = (long)Math.Round(ms);

8-5. UTCとローカル時刻の違いに注意する

DateTime.Now はローカル時刻を返します。

C#
DateTime local = DateTime.Now;

一方、DateTime.UtcNow はUTC時刻を返します。

C#
DateTime utc = DateTime.UtcNow;

ローカル時刻は、実行環境のタイムゾーンに依存します。

そのため、サーバーやユーザーの地域が異なる場合、同じコードでも異なる時刻になる可能性があります。

APIやデータベースに日時を保存する場合は、UTCで保存する設計がよく使われます。

C#
DateTime utcNow = DateTime.UtcNow;

表示するときにローカル時刻へ変換する方法です。

C#
DateTime localTime = utcNow.ToLocalTime();

Console.WriteLine(localTime.ToString("yyyy/MM/dd HH:mm:ss.fff"));

ローカル時刻とUTCを混在させると、時間差の計算やログ解析で混乱しやすいため注意が必要です。

8-6. タイムゾーンをまたぐ処理ではDateTimeOffsetを使う

タイムゾーンをまたぐ処理では、DateTime よりも DateTimeOffset が適している場合があります。

DateTimeOffset は、日時に加えてUTCからのオフセットも保持できます。

C#
DateTimeOffset now = DateTimeOffset.Now;

Console.WriteLine(now.ToString("yyyy/MM/dd HH:mm:ss.fff zzz"));

実行結果の例です。

2026/06/18 10:15:30.347 +09:00

UTCで扱いたい場合は、DateTimeOffset.UtcNow を使います。

C#
DateTimeOffset utcNow = DateTimeOffset.UtcNow;

Console.WriteLine(utcNow.ToString("yyyy/MM/dd HH:mm:ss.fff zzz"));

Unixミリ秒との変換にも DateTimeOffset が便利です。

C#
long unixMs = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

DateTimeOffset date = DateTimeOffset.FromUnixTimeMilliseconds(unixMs);

API連携、分散システム、海外ユーザー向けアプリなどでは、時刻の基準を明確にすることが重要です。

9. 実践で使えるミリ秒処理のサンプルコード

9-1. 現在時刻をミリ秒付きでログ出力する

現在時刻をミリ秒付きでログ出力するサンプルです。

C#
public static void Log(string message)
{
    string timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");

    Console.WriteLine($"[{timestamp}] {message}");
}

Log("処理を開始しました");
Log("データを読み込みました");
Log("処理を終了しました");

実行結果の例です。

[2026-06-18 10:15:30.347] 処理を開始しました
[2026-06-18 10:15:30.512] データを読み込みました
[2026-06-18 10:15:30.789] 処理を終了しました

ミリ秒付きでログを出すと、短い間隔で実行された処理の順序や時間差を確認しやすくなります。

ファイル名にログ日時を含めたい場合は、次のようにします。

C#
string fileName = $"log_{DateTime.Now:yyyyMMdd_HHmmss_fff}.txt";

Console.WriteLine(fileName);

9-2. 処理時間をミリ秒で表示する

処理時間をミリ秒で表示するには、Stopwatch を使います。

C#
using System.Diagnostics;

public static void Main()
{
    Stopwatch sw = Stopwatch.StartNew();

    // 計測したい処理
    Thread.Sleep(1200);

    sw.Stop();

    Console.WriteLine($"処理時間: {sw.ElapsedMilliseconds}ms");
}

実行結果の例です。

処理時間: 1203ms

小数を含むミリ秒で表示したい場合は、Elapsed.TotalMilliseconds を使います。

C#
Console.WriteLine($"処理時間: {sw.Elapsed.TotalMilliseconds:F3}ms");

実行結果の例です。

処理時間: 1203.456ms