DateTime 構造体

定義

通常、日付や時刻として表現される瞬間を表します。

public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable
public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System::Runtime::Serialization::ISerializable
public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, ISpanFormattable, System::Runtime::Serialization::ISerializable
public value class DateTime : IComparable, IConvertible, IFormattable
public value class DateTime : IComparable, IComparable<DateTime>, IEquatable<DateTime>, IFormattable
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializable
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, ISpanFormattable, System.Runtime.Serialization.ISerializable
[System.Serializable]
public struct DateTime : IComparable, IConvertible, IFormattable
[System.Serializable]
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, System.Runtime.Serialization.ISerializable
public struct DateTime : IComparable, IComparable<DateTime>, IEquatable<DateTime>, IFormattable
type DateTime = struct
    interface IConvertible
    interface IFormattable
type DateTime = struct
    interface IConvertible
    interface IFormattable
    interface ISerializable
type DateTime = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
    interface ISerializable
[<System.Serializable>]
type DateTime = struct
    interface IFormattable
    interface IConvertible
[<System.Serializable>]
type DateTime = struct
    interface IFormattable
    interface IConvertible
    interface ISerializable
type DateTime = struct
    interface IFormattable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IFormattable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IFormattable, ISerializable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), ISerializable, ISpanFormattable
Public Structure DateTime
Implements IComparable, IConvertible, IFormattable
Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IEquatable(Of DateTime), IFormattable
継承
DateTime
属性
実装

注釈

重要

和暦の時代 (年号) は天皇の代に基づいているため、変更されることが予想されます。 たとえば、JapaneseCalendarJapaneseLunisolarCalendar において、2019 年 5 月 1 日から令和時代が始まることになりました。 このような時代 (年号) の変更は、これらのカレンダーを使用するすべてのアプリケーションに影響します。 詳細およびアプリケーションが影響を受けるかどうかを判断する方法については、「 .net の日本語カレンダーでの新しい時代 (年号) の処理」を参照してください。 Windows システムでアプリケーションをテストして、時代 (年号) の変化に対応できるようにする方法については、「日本語時代 (年号) の変更に備えてアプリケーションを準備する」を参照してください。 複数の時代 (年号) を含む暦をサポートする .NET の機能について、および複数の時代 (年号) をサポートする予定表を操作する場合のベストプラクティスについては、「時代と作業

注意

この記事にある C# の例の一部は、Try.NET インライン コード ランナーとプレイグラウンドで実行されます。 [実行] ボタンを選択すると、対話型ウィンドウで例が実行されます。 コードを実行したら、コードを変更し、 [実行] をもう一度選択して変更後のコードを実行できます。 変更後のコードが対話型ウィンドウで実行されるか、コンパイルできなかった場合、対話型ウィンドウにすべての C# コンパイラ エラー メッセージが表示されます。

Try.NET インライン コード ランナーとプレイグラウンドのローカル タイム ゾーンは、協定世界時 (UTC) です。 これは、DateTimeDateTimeOffsetTimeZoneInfo 型とそのメンバーについて説明する例の、動作と出力に影響を与える可能性があります。

この記事には、型を使用する例がいくつか含まれてい DateTime ます。

初期化の例

DateTimeオブジェクトを文字列として書式設定する

オブジェクトとしての文字列の解析 DateTime

DateTime 解決

カルチャとカレンダー

永続化

このセクションには、構造体の一般的な使用方法に関するトピックが含まれてい DateTime ます。

値の型は、 DateTime 00:00:00 (午前0時)、1月1日、0001キリスト Domini (共通時代 (年号)、9999年12月31日の 11:59:59 P.M. までの値を含む日付と時刻を表します。 です。

時刻値は、ティックと呼ばれる100ナノ秒単位で測定されます。 特定の日付は、0001年1月1日午前12:00 時からのタイマー刻みの数です。 西暦カレンダーに含ま GregorianCalendar れています。 この数値には、閏月によって追加されるティックは含まれません。 たとえば、31241376000000000L のティック値は、12:00:00 0100 年1月01日金曜日の午前0時を表します。 DateTime値は常に明示的または既定の暦のコンテキストで表されます。

注意

分や秒などの他の時間間隔に変換するティック値を使用する場合は TimeSpan.TicksPerDay 、、、 TimeSpan.TicksPerHour TimeSpan.TicksPerMinuteTimeSpan.TicksPerSecond 、または定数を使用して TimeSpan.TicksPerMillisecond 変換を実行する必要があります。 たとえば、指定されたタイマー刻みの数で表される秒数を値のコンポーネントに追加するに Second は、式を使用し DateTime dateValue.Second + nTicks/Timespan.TicksPerSecond ます。

この記事に記載されている一連の例のソースは、GitHub の docs リポジトリにあるVisual BasicまたはC#のいずれかで参照できます。

注意

DateTime特定のタイムゾーンで日付と時刻の値を操作するための構造体の代替手段として、 DateTimeOffset 構造体があります。 構造体は、プライベートフィールドに DateTimeOffset 日付と時刻の情報を格納し、 DateTime その日付と時刻がプライベートフィールドの UTC と異なる時間を分単位で格納し Int16 ます。 これにより、値に DateTimeOffset 特定のタイムゾーンの時刻を反映させること DateTime ができます。一方、値には、UTC とローカルタイムゾーンの時刻のみが明確に反映されます。 日付と時刻の値を操作するときに構造体または構造体を使用する場合の詳細については DateTime DateTimeOffset 、「 DateTime、DateTimeOffset、TimeSpan、および TimeZoneInfo の使い分け」を参照してください。

DateTime オブジェクトの初期化

新しい値には、 DateTime 次のようなさまざまな方法で初期値を割り当てることができます。

  • コンストラクターを呼び出すと (値の引数を指定する場合)、暗黙のパラメーターなしのコンストラクターを使用することもできます。
  • DateTimeプロパティまたはメソッドの戻り値にを割り当てる。
  • DateTime文字列形式から値を解析しています。
  • Visual Basic 固有の言語機能を使用してをインスタンス化する DateTime

次のコードスニペットは、それぞれの例を示しています。

コンストラクターの呼び出し

DateTime日付と時刻の値 (年、月、日、タイマー刻みの数など) の要素を指定するコンストラクターの任意のオーバーロードを呼び出します。 次のコードでは、 DateTime 年、月、日、時、分、および秒を指定するコンストラクターを使用して、特定の日付を作成します。

Dim date1 As New Date(2008, 5, 1, 8, 30, 52)
var date1 = new DateTime(2008, 5, 1, 8, 30, 52);
Console.WriteLine(date1);

DateTimeを既定値に初期化する必要がある場合は、構造体の暗黙的なパラメーターなしのコンストラクターを呼び出し DateTime ます。 (値型の暗黙的なパラメーターなしのコンストラクターの詳細については、「 値型」を参照してください)。一部のコンパイラでは、値を DateTime 明示的に代入せずに値を宣言することもできます。 明示的な初期化を行わずに値を作成した場合も、既定値になります。 次の例は、 DateTime C# と Visual Basic の暗黙のパラメーターなしのコンストラクターと、Visual Basic に割り当てられていない宣言を示してい DateTime ます。

Dim dat1 As DateTime
' The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat1.ToString(System.Globalization.CultureInfo.InvariantCulture))
' The following method call displays True.
Console.WriteLine(dat1.Equals(Date.MinValue))

Dim dat2 As New DateTime()
' The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat2.ToString(System.Globalization.CultureInfo.InvariantCulture))
' The following method call displays True.
Console.WriteLine(dat2.Equals(Date.MinValue))
var dat1 = new DateTime();
// The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat1.ToString(System.Globalization.CultureInfo.InvariantCulture));
// The following method call displays True.
Console.WriteLine(dat1.Equals(DateTime.MinValue));
計算値の割り当て

オブジェクトには、 DateTime プロパティまたはメソッドによって返された日付と時刻の値を割り当てることができます。 次の例では、現在の日付と時刻、現在の世界協定時刻 (UTC) の日付と時刻、および現在の日付を3つの新しい変数に代入し DateTime ます。

Dim date1 As Date = Date.Now
Dim date2 As Date = Date.UtcNow
Dim date3 As Date = Date.Today
DateTime date1 = DateTime.Now;
DateTime date2 = DateTime.UtcNow;
DateTime date3 = DateTime.Today;
DateTime を表す文字列を解析する

Parse、、 ParseExact TryParse 、およびの TryParseExact 各メソッドはすべて、文字列をそれと等価な日付と時刻の値に変換します。 次の例では ParseParseExact メソッドとメソッドを使用して文字列を解析し、値に変換し DateTime ます。 2番目の形式では、文字列形式の日付と時刻を表すの ISO 8601 標準でサポートされている形式を使用します。 この標準表現は、多くの場合、web サービスで日付情報を転送するために使用されます。

Dim dateString As String = "5/1/2008 8:30:52 AM"
Dim date1 As Date = Date.Parse(dateString,
                       System.Globalization.CultureInfo.InvariantCulture)
Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As Date = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
                              System.Globalization.CultureInfo.InvariantCulture)
Console.WriteLine(dateISO8602)
var dateString = "5/1/2008 8:30:52 AM";
DateTime date1 = DateTime.Parse(dateString,
                          System.Globalization.CultureInfo.InvariantCulture);
var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
                                System.Globalization.CultureInfo.InvariantCulture);

TryParseメソッドと TryParseExact メソッドは、文字列が値の有効な表現であるかどうかを示します。文字列がの場合は、 DateTime 変換を実行します。

Visual Basic の言語固有の構文

次の Visual Basic ステートメントは、新しい値を初期化し DateTime ます。

Dim date1 As Date = #5/1/2008 8:30:52AM#

DateTime 値とその文字列形式

内部的には、すべての DateTime 値は、0001年1月1日午前0時12:00:00 以降に経過したティック数 (100 ナノ秒間隔の数) として表されます。 実際の DateTime 値は、表示されたときの値の表示方法とは関係ありません。 値の外観 DateTime は、値を文字列形式に変換する書式設定操作の結果です。

日付と時刻の値の外観は、カルチャ、国際基準、アプリケーションの要件、および個人設定によって異なります。 DateTime構造体は、のオーバーロードを使用して日付と時刻の値を書式設定する際の柔軟性を備えて ToString います。 既定の DateTime.ToString() メソッドは、現在のカルチャの短い日付と長い形式の時刻パターンを使用して、日付と時刻の値の文字列形式を返します。 次の例では、既定のメソッドを使用し DateTime.ToString() ます。 現在のカルチャの短い日付パターンと長い時刻パターンを使用して、日付と時刻が表示されます。 En-us カルチャは、この例が実行されたコンピューター上の現在のカルチャです。

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString());
// For en-US culture, displays 3/1/2008 7:00:00 AM
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString())
' For en-US culture, displays 3/1/2008 7:00:00 AM

場合によっては、特定のカルチャで日付の書式を設定して、サーバーがクライアントとは異なるカルチャに存在する可能性がある web シナリオをサポートする必要があります。 カルチャを指定するには、メソッドを使用して、 DateTime.ToString(IFormatProvider) 特定のカルチャで短い日付と長い時刻の表現を作成します。 次の例では、 DateTime.ToString(IFormatProvider) メソッドを使用して、fr-FR カルチャの短い日付と長い時刻パターンを使用して日付と時刻を表示します。

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 01/03/2008 07:00:00
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 01/03/2008 07:00:00

他のアプリケーションでは、日付の異なる文字列表現が必要な場合があります。 メソッドは、現在のカルチャの書式指定規則を使用して、標準書式指定子またはカスタム書式指定子によって定義された文字列 DateTime.ToString(String) 形式を返します。 次の例では、 メソッドを使用して、en-US カルチャ (例が実行されたコンピューター上の現在のカルチャ) の完全な日付と時刻パターン DateTime.ToString(String) を表示します。

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F"));
// Displays Saturday, March 01, 2008 7:00:00 AM
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F"))
' Displays Saturday, March 01, 2008 7:00:00 AM

最後に、 メソッドを使用して、カルチャと形式の両方を指定 DateTime.ToString(String, IFormatProvider) できます。 次の例では、 DateTime.ToString(String, IFormatProvider) メソッドを使用して、fr-FR カルチャの完全な日時パターンを表示します。

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F", new System.Globalization.CultureInfo("fr-FR")));
// Displays samedi 1 mars 2008 07:00:00
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F", New System.Globalization.CultureInfo("fr-FR")))
' Displays samedi 1 mars 2008 07:00:00

オーバーロード DateTime.ToString(String) は、カスタム書式指定文字列と一緒に使用して、他の形式を指定する場合にも使用できます。 次の例は、Web サービスでよく使用される ISO 8601 標準形式を使用して文字列を書式設定する方法を示しています。 Iso 8601 形式には、対応する標準書式指定文字列が含まれます。

var date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("yyyyMMddTHH:mm:ssZ"));
// Displays 20080301T07:00:00Z
Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("yyyyMMddTHH:mm:ssZ"))
' Displays 20080301T07:00:00Z

値の書式設定の詳細については、「標準の日付と時刻の書式指定文字列」および「カスタム DateTime 日時書式 指定 文字列 」を参照してください

文字列からの DateTime 値の解析

解析では、日付と時刻の文字列形式が値に変換 DateTime されます。 通常、日付と時刻の文字列は、アプリケーションで 2 つの異なる使用方法を持っています。

  • 日付と時刻はさまざまな形式を受け取り、現在のカルチャまたは特定のカルチャの規則を反映します。 たとえば、アプリケーションでは、現在のカルチャが en-US であるユーザーに、"2013 年 12 月 15 日" または "2013 年 12 月 15 日" という日付値を入力できます。 現在のカルチャが en-gb のユーザーは、日付値を "15/12/2013" または "15 December 2013" として入力できます。

  • 日付と時刻は、定義済みの形式で表されます。 たとえば、アプリケーションは、アプリが実行されているカルチャとは別に、日付を "20130103" としてシリアル化します。 アプリケーションでは、現在のカルチャの短い日付形式で日付を入力する必要がある場合があります。

または メソッドを使用して、カルチャで使用される一般的な日付と時刻の形式の 1 つから値に Parse TryParse 文字列を変換 DateTime します。 次の例は、 を使用して、カルチャ固有の異なる形式の日付文字列を値 TryParse に変換する方法を示 DateTime しています。 現在のカルチャを英語 (英国) に変更し、 メソッドを呼び出して日時文字列の配列 GetDateTimeFormats() を生成します。 次に、配列内の各要素を メソッドに渡 TryParse します。 この例の出力は、解析メソッドがカルチャ固有の各日時文字列を正常に変換できたと示しています。

System.Threading.Thread.CurrentThread.CurrentCulture =
    System.Globalization.CultureInfo.CreateSpecificCulture("en-GB");

var date1 = new DateTime(2013, 6, 1, 12, 32, 30);
var badFormats = new List<String>();

Console.WriteLine($"{"Date String",-37} {"Date",-19}\n");
foreach (var dateString in date1.GetDateTimeFormats())
{
    DateTime parsedDate;
    if (DateTime.TryParse(dateString, out parsedDate))
        Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19}");
    else
        badFormats.Add(dateString);
}

// Display strings that could not be parsed.
if (badFormats.Count > 0)
{
    Console.WriteLine("\nStrings that could not be parsed: ");
    foreach (var badFormat in badFormats)
        Console.WriteLine($"   {badFormat}");
}
// Press "Run" to see the output.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")

Dim date1 As New DateTime(2013, 6, 1, 12, 32, 30)
Dim badFormats As New List(Of String)

Console.WriteLine($"{"Date String",-37} {"Date",-19}")
Console.WriteLine()
For Each dateString As String In date1.GetDateTimeFormats()
    Dim parsedDate As DateTime
    If DateTime.TryParse(dateString, parsedDate) Then
        Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19:g}")
    Else
        badFormats.Add(dateString)
    End If
Next

' Display strings that could not be parsed.
If badFormats.Count > 0 Then
    Console.WriteLine()
    Console.WriteLine("Strings that could not be parsed: ")
    For Each badFormat In badFormats
        Console.WriteLine($"   {badFormat}")
    Next
End If
' The example displays the following output:
'       Date String                           Date               
'       
'       01/06/2013                            01/06/2013 00:00:00
'       01/06/13                              01/06/2013 00:00:00
'       1/6/13                                01/06/2013 00:00:00
'       1.6.13                                01/06/2013 00:00:00
'       2013-06-01                            01/06/2013 00:00:00
'       01 June 2013                          01/06/2013 00:00:00
'       1 June 2013                           01/06/2013 00:00:00
'       01 June 2013 12:32                    01/06/2013 12:32:00
'       01 June 2013 12:32                    01/06/2013 12:32:00
'       01 June 2013 12:32 PM                 01/06/2013 12:32:00
'       01 June 2013 12:32 PM                 01/06/2013 12:32:00
'       1 June 2013 12:32                     01/06/2013 12:32:00
'       1 June 2013 12:32                     01/06/2013 12:32:00
'       1 June 2013 12:32 PM                  01/06/2013 12:32:00
'       1 June 2013 12:32 PM                  01/06/2013 12:32:00
'       01 June 2013 12:32:30                 01/06/2013 12:32:30
'       01 June 2013 12:32:30                 01/06/2013 12:32:30
'       01 June 2013 12:32:30 PM              01/06/2013 12:32:30
'       01 June 2013 12:32:30 PM              01/06/2013 12:32:30
'       1 June 2013 12:32:30                  01/06/2013 12:32:30
'       1 June 2013 12:32:30                  01/06/2013 12:32:30
'       1 June 2013 12:32:30 PM               01/06/2013 12:32:30
'       1 June 2013 12:32:30 PM               01/06/2013 12:32:30
'       01/06/2013 12:32                      01/06/2013 12:32:00
'       01/06/2013 12:32                      01/06/2013 12:32:00
'       01/06/2013 12:32 PM                   01/06/2013 12:32:00
'       01/06/2013 12:32 PM                   01/06/2013 12:32:00
'       01/06/13 12:32                        01/06/2013 12:32:00
'       01/06/13 12:32                        01/06/2013 12:32:00
'       01/06/13 12:32 PM                     01/06/2013 12:32:00
'       01/06/13 12:32 PM                     01/06/2013 12:32:00
'       1/6/13 12:32                          01/06/2013 12:32:00
'       1/6/13 12:32                          01/06/2013 12:32:00
'       1/6/13 12:32 PM                       01/06/2013 12:32:00
'       1/6/13 12:32 PM                       01/06/2013 12:32:00
'       1.6.13 12:32                          01/06/2013 12:32:00
'       1.6.13 12:32                          01/06/2013 12:32:00
'       1.6.13 12:32 PM                       01/06/2013 12:32:00
'       1.6.13 12:32 PM                       01/06/2013 12:32:00
'       2013-06-01 12:32                      01/06/2013 12:32:00
'       2013-06-01 12:32                      01/06/2013 12:32:00
'       2013-06-01 12:32 PM                   01/06/2013 12:32:00
'       2013-06-01 12:32 PM                   01/06/2013 12:32:00
'       01/06/2013 12:32:30                   01/06/2013 12:32:30
'       01/06/2013 12:32:30                   01/06/2013 12:32:30
'       01/06/2013 12:32:30 PM                01/06/2013 12:32:30
'       01/06/2013 12:32:30 PM                01/06/2013 12:32:30
'       01/06/13 12:32:30                     01/06/2013 12:32:30
'       01/06/13 12:32:30                     01/06/2013 12:32:30
'       01/06/13 12:32:30 PM                  01/06/2013 12:32:30
'       01/06/13 12:32:30 PM                  01/06/2013 12:32:30
'       1/6/13 12:32:30                       01/06/2013 12:32:30
'       1/6/13 12:32:30                       01/06/2013 12:32:30
'       1/6/13 12:32:30 PM                    01/06/2013 12:32:30
'       1/6/13 12:32:30 PM                    01/06/2013 12:32:30
'       1.6.13 12:32:30                       01/06/2013 12:32:30
'       1.6.13 12:32:30                       01/06/2013 12:32:30
'       1.6.13 12:32:30 PM                    01/06/2013 12:32:30
'       1.6.13 12:32:30 PM                    01/06/2013 12:32:30
'       2013-06-01 12:32:30                   01/06/2013 12:32:30
'       2013-06-01 12:32:30                   01/06/2013 12:32:30
'       2013-06-01 12:32:30 PM                01/06/2013 12:32:30
'       2013-06-01 12:32:30 PM                01/06/2013 12:32:30
'       01 June                               01/06/2013 00:00:00
'       01 June                               01/06/2013 00:00:00
'       2013-06-01T12:32:30.0000000           01/06/2013 12:32:30
'       2013-06-01T12:32:30.0000000           01/06/2013 12:32:30
'       Sat, 01 Jun 2013 12:32:30 GMT         01/06/2013 05:32:30
'       Sat, 01 Jun 2013 12:32:30 GMT         01/06/2013 05:32:30
'       2013-06-01T12:32:30                   01/06/2013 12:32:30
'       12:32                                 22/04/2013 12:32:00
'       12:32                                 22/04/2013 12:32:00
'       12:32 PM                              22/04/2013 12:32:00
'       12:32 PM                              22/04/2013 12:32:00
'       12:32:30                              22/04/2013 12:32:30
'       12:32:30                              22/04/2013 12:32:30
'       12:32:30 PM                           22/04/2013 12:32:30
'       12:32:30 PM                           22/04/2013 12:32:30
'       2013-06-01 12:32:30Z                  01/06/2013 05:32:30
'       01 June 2013 19:32:30                 01/06/2013 19:32:30
'       01 June 2013 19:32:30                 01/06/2013 19:32:30
'       01 June 2013 07:32:30 PM              01/06/2013 19:32:30
'       01 June 2013 7:32:30 PM               01/06/2013 19:32:30
'       1 June 2013 19:32:30                  01/06/2013 19:32:30
'       1 June 2013 19:32:30                  01/06/2013 19:32:30
'       1 June 2013 07:32:30 PM               01/06/2013 19:32:30
'       1 June 2013 7:32:30 PM                01/06/2013 19:32:30
'       June 2013                             01/06/2013 00:00:00
'       June 2013                             01/06/2013 00:00:00

メソッドと メソッド ParseExact を使用して、特定の形式または形式に一致する必要がある文字列 TryParseExact を値に変換 DateTime します。 解析メソッドのパラメーターとして、1 つ以上の日時書式指定文字列を指定します。 次の例では、 メソッドを使用して TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) 、"yyyyMMddd" 形式または "HHmmss" 形式である必要がある文字列を値に変換 DateTime します。

string[] formats = { "yyyyMMdd", "HHmmss" };
string[] dateStrings = { "20130816", "20131608", "  20130816   ",
                   "115216", "521116", "  115216  " };
DateTime parsedDate;

foreach (var dateString in dateStrings)
{
    if (DateTime.TryParseExact(dateString, formats, null,
                               System.Globalization.DateTimeStyles.AllowWhiteSpaces |
                               System.Globalization.DateTimeStyles.AdjustToUniversal,
                               out parsedDate))
        Console.WriteLine($"{dateString} --> {parsedDate:g}");
    else
        Console.WriteLine($"Cannot convert {dateString}");
}
// The example displays the following output:
//       20130816 --> 8/16/2013 12:00 AM
//       Cannot convert 20131608
//         20130816    --> 8/16/2013 12:00 AM
//       115216 --> 4/22/2013 11:52 AM
//       Cannot convert 521116
//         115216   --> 4/22/2013 11:52 AM
Dim formats() As String = {"yyyyMMdd", "HHmmss"}
Dim dateStrings() As String = {"20130816", "20131608",
                              "  20130816   ", "115216",
                              "521116", "  115216  "}
Dim parsedDate As DateTime

For Each dateString As String In dateStrings
    If DateTime.TryParseExact(dateString, formats, Nothing,
                           DateTimeStyles.AllowWhiteSpaces Or
                           DateTimeStyles.AdjustToUniversal,
                           parsedDate) Then
        Console.WriteLine($"{dateString} --> {parsedDate:g}")
    Else
        Console.WriteLine($"Cannot convert {dateString}")
    End If
Next
' The example displays the following output:
'       20130816 --> 8/16/2013 12:00 AM
'       Cannot convert 20131608
'         20130816    --> 8/16/2013 12:00 AM
'       115216 --> 4/22/2013 11:52 AM
'       Cannot convert 521116
'         115216   --> 4/22/2013 11:52 AM

の一般的な使用の 1 つは、文字列形式を Web サービス (通常は ParseExact ISO 8601 標準形式) から変換することです。 次のコードは、使用する正しい書式指定文字列を示しています。

var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
    System.Globalization.CultureInfo.InvariantCulture);
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}");
Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As DateTime = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", CultureInfo.InvariantCulture)
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}")

文字列を解析できない場合、 メソッドと Parse メソッド ParseExact は例外をスローします。 メソッド TryParseTryParseExact メソッドは、変換 Boolean が成功したかどうかを示す値を返します。 パフォーマンスが重要な TryParse TryParseExact シナリオでは、 メソッドまたは メソッドを使用する必要があります。 日付と時刻の文字列の解析操作は、エラー率が高くなる傾向があります。例外処理はコストがかかります。 文字列がユーザーによって入力される場合、または不明なソースから取得される場合は、これらのメソッドを使用します。

日付と時刻の値の解析の詳細については、「日付と時刻の 文字列の解析」を参照してください

DateTime 値

型の時刻値の説明は、多くの場合、標準 DateTime (UTC) 協定世界時使用して表されます。 協定世界時グリニッジ標準時 (GMT) の国際的に認められている名前です。 協定世界時は、経度 0 度 (UTC 原点) で測定された時間です。 夏時間は UTC には適用されません。

ローカル時刻は、特定のタイム ゾーンに対する相対時間です。 タイム ゾーンはタイム ゾーン オフセットに関連付けられている。 タイム ゾーン オフセットは、UTC の起点から時間単位で測定されたタイム ゾーンのずれです。 さらに、ローカル時刻は、必要に応じて夏時間の影響を受け、時間間隔調整を加算または減算します。 現地時刻は、タイム ゾーン オフセットを UTC に追加し、必要に応じて夏時間に合わせて調整することで計算されます。 UTC 原点のタイム ゾーン オフセットは 0 です。

UTC 時刻は、計算、比較、およびファイルへの日付と時刻の格納に適しています。 ローカル時刻は、デスクトップ アプリケーションのユーザー インターフェイスでの表示に適しています。 タイム ゾーン対応アプリケーション (多くの Web アプリケーションなど) も、他の多くのタイム ゾーンで動作する必要があります。

オブジェクトの プロパティが の場合、表される時刻がローカル時刻、UTC 時刻、または他のタイム ゾーンの時刻 Kind DateTime DateTimeKind.Unspecified かどうかは指定されません。

DateTime の解決

注意

経過時間を測定する値に対して日付と時刻の算術演算を実行する代わりに、 クラス DateTime を使用 Stopwatch できます。

プロパティ Ticks は、日付と時刻の値を秒の 1,000 万分の 1 単位で表します。 プロパティ Millisecond は、日付と時刻の値の秒の 1/10000 を返します。 プロパティの繰り返し呼 DateTime.Now び出しを使用して経過時間を測定する方法は、システム クロックによって異なります。 Windows 7 および Windows 8システムのシステム クロックの解像度は約 15 ミリ秒です。 この解決は、100 ミリ秒未満の短い時間間隔に影響します。

次の例は、システム クロックの解像度に対する現在の日付と時刻の値の依存性を示しています。 この例では、外側のループは 20 回繰り返され、内側のループは外側のループを遅延する機能を持っています。 外側のループ カウンターの値が 10 の場合、 メソッドを呼び出した場合 Thread.Sleep 、5 ミリ秒の遅延が発生します。 次の例は、 プロパティによって返されるミリ秒数を示しています。 の呼び出し DateTime.Now.Milliseconds 後にのみ変更されます Thread.Sleep

string output = "";
for (int ctr = 0; ctr <= 20; ctr++)
{
    output += String.Format($"{DateTime.Now.Millisecond}\n");
    // Introduce a delay loop.
    for (int delay = 0; delay <= 1000; delay++)
    { }

    if (ctr == 10)
    {
        output += "Thread.Sleep called...\n";
        System.Threading.Thread.Sleep(5);
    }
}
Console.WriteLine(output);
// Press "Run" to see the output.
Dim output As String = ""
For ctr As Integer = 0 To 20
    output += Date.Now.Millisecond.ToString() + vbCrLf
    ' Introduce a delay loop.
    For delay As Integer = 0 To 1000
    Next

    If ctr = 10 Then
        output += "Thread.Sleep called..." + vbCrLf
        Thread.Sleep(5)
    End If
Next
Console.WriteLine(output)
' The example displays output like the following:
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       Thread.Sleep called...
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143

DateTime 操作

や などの 構造体 DateTime を使用した計算では Add Subtract 、構造体の値は変更されない。 代わりに、計算の結果である値を持 DateTime つ新しい構造体が返されます。

タイム ゾーン間の変換操作 (UTC とローカル時刻の間、またはあるタイム ゾーンと別のタイム ゾーン間など) では夏時間が考慮されますが、算術演算と比較操作では考慮されません。

構造体 DateTime 自体では、あるタイム ゾーンから別のタイム ゾーンへの変換のサポートが制限されています。 メソッドを使用して UTC を現地時刻に変換するか、 メソッドを使用してローカル時刻から ToLocalTime ToUniversalTime UTC に変換できます。 ただし、 クラスでは、タイム ゾーン変換メソッドの完全なセットを使用 TimeZoneInfo できます。 これらの方法を使用して、世界のいずれかのタイム ゾーンの時刻を他のタイム ゾーンの時刻に変換します。

オブジェクトの計算と比較は DateTime 、オブジェクトが同じタイム ゾーン内の時間を表す場合にのみ意味があります。 2 つは疎結合ですが、 オブジェクトを使用して値のタイム ゾーン TimeZoneInfo DateTime を表します。 オブジェクトには、その日付と時刻の値のタイム ゾーンを表す オブジェクト DateTime を返す プロパティはありません。 プロパティ Kind は、 が DateTime UTC、現地時刻、または指定されていないかどうかを示します。 タイム ゾーン対応アプリケーションでは、オブジェクトが作成されたタイム ゾーンを特定するために、外部メカニズムに依存 DateTime する必要があります。 値と値のタイム ゾーンを表す オブジェクトの両方をラップする DateTime TimeZoneInfo DateTime 構造体を使用できます。 計算での UTC の使用と値との比較の詳細については、「日付と時刻を使用した算術演算 DateTime の実行」を参照してください

DateTime メンバーは、その操作を実行するためにグレゴリオ暦を暗黙的に使用します。 例外は、カレンダーを暗黙的に指定するメソッドです。 これには、カレンダーを指定するコンストラクターと、 から派生したパラメーターを持つメソッド ( IFormatProvider 例: ) が含まれます System.Globalization.DateTimeFormatInfo

型のメンバーによる操作では、leap 年や 1 か月の日数などの DateTime 詳細が考慮されます。

DateTime の値とカレンダー

クラス .NET Frameworkには、多数のカレンダー クラスが含まれています。そのすべてが クラスから派生 Calendar しています。 それらは次のとおりです。

重要

和暦の時代 (年号) は天皇の代に基づいているため、変更されることが予想されます。 たとえば、JapaneseCalendarJapaneseLunisolarCalendar において、2019 年 5 月 1 日から令和時代が始まることになりました。 このような時代 (年号) の変更は、これらのカレンダーを使用するすべてのアプリケーションに影響します。 詳細およびアプリケーションが影響を受けるかどうかを判断する方法については、「 .net の日本語カレンダーでの新しい時代 (年号) の処理」を参照してください。 Windows システムでアプリケーションをテストして、時代 (年号) の変化に対応できるようにする方法については、「日本語時代 (年号) の変更に備えてアプリケーションを準備する」を参照してください。 複数の時代 (年号) を含む暦をサポートする .NET の機能について、および複数の時代 (年号) をサポートする予定表を操作する場合のベストプラクティスについては、「時代と作業

各カルチャでは、その読み取り専用プロパティで定義された既定のカレンダーが使用 CultureInfo.Calendar されます。 各カルチャは、その読み取り専用プロパティで定義された 1 つ以上のカレンダーをサポート CultureInfo.OptionalCalendars できます。 特定のオブジェクトによって現在使用されているカレンダー CultureInfo は、 プロパティによって定義 DateTimeFormatInfo.Calendar されます。 配列で見つかったカレンダーの 1 つである必要 CultureInfo.OptionalCalendars があります。

カルチャの現在のカレンダーは、そのカルチャのすべての書式設定操作で使用されます。 たとえば、タイの文化の既定の暦は、 クラスによって表されるタイのタイ古暦 ThaiBuddhistCalendar です。 タイのタイの文化を表す オブジェクトが日付と時刻の書式設定操作で使用される場合、タイのタイの時代 (年号) カレンダーが既定で CultureInfo 使用されます。 グレゴリオ暦は、次の例に示すように、カルチャの プロパティが変更 DateTimeFormatInfo.Calendar された場合にのみ使用されます。

var thTH = new System.Globalization.CultureInfo("th-TH");
var value = new DateTime(2016, 5, 28);

Console.WriteLine(value.ToString(thTH));

thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00
Dim thTH As New CultureInfo("th-TH")
Dim value As New DateTime(2016, 5, 28)

Console.WriteLine(value.ToString(thTH))

thTH.DateTimeFormat.Calendar = New GregorianCalendar()
Console.WriteLine(value.ToString(thTH))
' The example displays the following output:
'       28/5/2559 0:00:00
'       28/5/2016 0:00:00

次の例に示すように、カルチャの現在のカレンダーは、そのカルチャのすべての解析操作でも使用されます。

var thTH = new System.Globalization.CultureInfo("th-TH");
var value = DateTime.Parse("28/05/2559", thTH);
Console.WriteLine(value.ToString(thTH));

thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00
Private Sub ThaiBuddhistEraParse()
    Dim thTH As New CultureInfo("th-TH")
    Dim value As DateTime = DateTime.Parse("28/5/2559", thTH)
    Console.WriteLine(value.ToString(thTH))

    thTH.DateTimeFormat.Calendar = New GregorianCalendar()
    Console.WriteLine(value.ToString(thTH))
    ' The example displays the following output:
    '       28/5/2559 0:00:00
    '       28/5/2016 0:00:00
End Sub

パラメーターを含む DateTime DateTimeコンストラクターを呼び出し、そのカレンダーを表す オブジェクトを渡すことによって、特定の暦の日付と時刻の要素 (年、月、日の数) を使用して値をインスタンス化します。 calendar Calendar 次の例では、カレンダーの日付と時刻の要素を使用 ThaiBuddhistCalendar します。

var thTH = new System.Globalization.CultureInfo("th-TH");
var dat = new DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar);
Console.WriteLine($"Thai Buddhist era date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Gregorian date:   {dat:d}");
// The example displays the following output:
//       Thai Buddhist Era Date:  28/5/2559
//       Gregorian Date:     28/05/2016
Dim thTH As New CultureInfo("th-TH")
Dim dat As New DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)
Console.WriteLine($"Thai Buddhist Era date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Gregorian date:   {dat:d}")
' The example displays the following output:
'       Thai Buddhist Era Date:  28/5/2559
'       Gregorian Date:     28/05/2016

DateTime パラメーターを含めないコンストラクターは、日付と時刻の要素がグレゴリオ暦の単位 calendar として表されると想定します。

その他 DateTime のすべてのプロパティとメソッドでは、グレゴリオ暦が使用されます。 たとえば、 プロパティはグレゴリオ暦の年を返し、 メソッドは パラメーターがグレゴリオ暦の年 DateTime.Year DateTime.IsLeapYear(Int32) year と見なします。 グレ DateTime ゴリオ暦を使用する各メンバーには、特定の暦を使用する クラス Calendar の対応するメンバーがあります。 たとえば、 メソッドは特定の暦の年を返し、 メソッドはパラメーターを特定の暦の年 Calendar.GetYear Calendar.IsLeapYear year 数として解釈します。 次の例では、 クラスの と DateTime 対応するメンバーの両方を使用 ThaiBuddhistCalendar します。

var thTH = new System.Globalization.CultureInfo("th-TH");
var cal = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(2559, 5, 28, cal);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Year: {cal.GetYear(dat)}");
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}\n");

Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Year: {dat.Year}");
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}");
// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :   28/5/2559
//       Year: 2559
//       Leap year :   True
//
//       Using the Gregorian calendar
//       Date :   28/05/2016
//       Year: 2016
//       Leap year :   True
Dim thTH As New CultureInfo("th-TH")
Dim cal As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(2559, 5, 28, cal)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Year: {cal.GetYear(dat)}")
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}")
Console.WriteLine()

Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Year: {dat.Year}")
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}")
' The example displays the following output:
'       Using the Thai Buddhist Era calendar
'       Date :   28/5/2559
'       Year: 2559
'       Leap year :   True
'
'       Using the Gregorian calendar
'       Date :   28/05/2016
'       Year: 2016
'       Leap year :   True

構造体 DateTime には、 DayOfWeek グレゴリオ暦の週の日付を返す プロパティが含まれています。 年の週番号を取得できるメンバーは含まれます。 年の週を取得するには、個々のカレンダーの メソッドを呼び出 Calendar.GetWeekOfYear します。 具体的な例を次に示します。

var thTH = new System.Globalization.CultureInfo("th-TH");
var thCalendar = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(1395, 8, 18, thCalendar);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}");
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}\n");

var greg = new System.Globalization.GregorianCalendar();
Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Day of Week: {dat.DayOfWeek}");
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay,DayOfWeek.Sunday)}");
// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :  18/8/1395
//       Day of Week: Sunday
//       Week of year: 34
//
//       Using the Gregorian calendar
//       Date :  18/08/0852
//       Day of Week: Sunday
//       Week of year: 34
Dim thTH As New CultureInfo("th-TH")
Dim thCalendar As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(1395, 8, 18, thCalendar)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}")
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
Console.WriteLine()

Dim greg As Calendar = New GregorianCalendar()
Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Day of Week: {dat.DayOfWeek}")
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
' The example displays the following output:
'       Using the Thai Buddhist Era calendar
'       Date :  18/8/1395
'       Day of Week: Sunday
'       Week of year: 34
'       
'       Using the Gregorian calendar
'       Date :  18/08/0852
'       Day of Week: Sunday
'       Week of year: 34

日付とカレンダーの詳細については、「カレンダーの操作 」を参照してください

DateTime 値の永続化

値は、次 DateTime の 4 つの方法で保持できます。

選択した手法に関係なく、値を復元するルーチンがデータを失わないか、例外 DateTime をスローしない必要があります。 DateTime 値はラウンドトリップする必要があります。 つまり、元の値と復元された値は同じになります。 また、元の値が 1 つの時刻を表す場合は、復元されるのと同じ時刻 DateTime を識別する必要があります。

値を文字列として保持する

文字列として保持される DateTime 値を正常に復元するには、次の規則に従います。

  • 文字列を永続化した場合と同様に、カルチャ固有の書式設定を想定します。 現在のカルチャが保存されたシステムのカルチャと異なるシステムで文字列を確実に復元するには、 オーバーロードを呼び出し、インバリアント カルチャの規則を使用して文字列を保存します。 ToString または オーバーロード Parse(String, IFormatProvider, DateTimeStyles)TryParse(String, IFormatProvider, DateTimeStyles, DateTime) 呼び出して、インバリアント カルチャの規則を使用して文字列を復元します。 現在のスレッド ToString() カルチャの規則を使用する 、、または オーバーロード Parse(String) TryParse(String, DateTime) を使用しない。

  • 日付が 1 つの時刻を表す場合は、別のタイム ゾーンでも、復元された時刻と同じ時間を表す必要があります。 値を DateTime 保存する前協定世界時 (UTC) に変換します。 タイム ゾーン情報と共に値をシリアル化できます。 この方法の詳細については、「DateTime データとタイム ゾーン データのシリアル化」を参照してください

値を文字列として永続化するときに発生する最も一般的なエラーは、既定または現在のカルチャの書式設定規則 DateTime に依存する場合です。 文字列を保存および復元するときに、現在のカルチャが異なる場合に問題が発生します。 次の例は、これらの問題を示しています。 現在のカルチャの書式設定規則 (この場合は英語 (米国) を使用して、5 つの日付を保存します。 これは、異なるカルチャの書式設定規則 (この例では英語 (英国)) を使用して日付を復元します。 2 つのカルチャの書式設定規則は異なっているので、2 つの日付を復元できないので、残りの 3 つの日付は正しく解釈されません。 また、元の日付と時刻の値が 1 つの時刻を表す場合、タイム ゾーン情報が失われるため、復元された時刻は正しくありません。

public static void PersistAsLocalStrings()
{
    SaveLocalDatesAsString();
    RestoreLocalDatesFromString();
}

private static void SaveLocalDatesAsString()
{
    DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
                   new DateTime(2014, 7, 10, 23, 49, 0),
                   new DateTime(2015, 1, 10, 1, 16, 0),
                   new DateTime(2014, 12, 20, 21, 45, 0),
                   new DateTime(2014, 6, 2, 15, 14, 0) };
    string output = null;

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        output += dates[ctr].ToString() + (ctr != dates.Length - 1 ? "|" : "");
    }
    var sw = new StreamWriter(filenameTxt);
    sw.Write(output);
    sw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreLocalDatesFromString()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    StreamReader sr = new StreamReader(filenameTxt);
    string[] inputValues = sr.ReadToEnd().Split(new char[] { '|' },
                                                StringSplitOptions.RemoveEmptyEntries);
    sr.Close();
    Console.WriteLine("The dates on an {0} system:",
                      Thread.CurrentThread.CurrentCulture.Name);
    foreach (var inputValue in inputValues)
    {
        DateTime dateValue;
        if (DateTime.TryParse(inputValue, out dateValue))
        {
            Console.WriteLine($"'{inputValue}' --> {dateValue:f}");
        }
        else
        {
            Console.WriteLine("Cannot parse '{inputValue}'");
        }
    }
    Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       Cannot parse //6/14/2014 6:32:00 AM//
//       //7/10/2014 11:49:00 PM// --> 07 October 2014 23:49
//       //1/10/2015 1:16:00 AM// --> 01 October 2015 01:16
//       Cannot parse //12/20/2014 9:45:00 PM//
//       //6/2/2014 3:14:00 PM// --> 06 February 2014 15:14
//       Restored dates...
Public Sub PersistAsLocalStrings()
    SaveDatesAsStrings()
    RestoreDatesAsStrings()
End Sub

Private Sub SaveDatesAsStrings()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim output As String = Nothing

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        output += dates(ctr).ToString() + If(ctr <> dates.Length - 1, "|", "")
    Next
    Dim sw As New StreamWriter(filenameTxt)
    sw.Write(output)
    sw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsStrings()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim sr As New StreamReader(filenameTxt)
    Dim inputValues As String() = sr.ReadToEnd().Split({"|"c}, StringSplitOptions.RemoveEmptyEntries)
    sr.Close()
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each inputValue In inputValues
        Dim dateValue As Date
        If DateTime.TryParse(inputValue, dateValue) Then
            Console.WriteLine($"'{inputValue}' --> {dateValue:f}")
        Else
            Console.WriteLine($"Cannot parse '{inputValue}'")
        End If
    Next
    Console.WriteLine("Restored dates...")
End Sub
' When saved on an en-US system, the example displays the following output:
'       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
'       The dates on an en-US system:
'       Saturday, June 14, 2014 6:32 AM
'       Thursday, July 10, 2014 11:49 PM
'       Saturday, January 10, 2015 1:16 AM
'       Saturday, December 20, 2014 9:45 PM
'       Monday, June 02, 2014 3:14 PM
'       Saved dates...
'
' When restored on an en-GB system, the example displays the following output:
'       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
'       The dates on an en-GB system:
'       Cannot parse '6/14/2014 6:32:00 AM'
'       '7/10/2014 11:49:00 PM' --> 07 October 2014 23:49
'       '1/10/2015 1:16:00 AM' --> 01 October 2015 01:16
'       Cannot parse '12/20/2014 9:45:00 PM'
'       '6/2/2014 3:14:00 PM' --> 06 February 2014 15:14
'       Restored dates...

値を正常にラウンド DateTime トリップするには、次の手順に従います。

  1. 値が 1 つの時刻を表す場合は、 メソッドを呼び出して、ローカル時刻から UTC に変換 ToUniversalTime します。
  2. または オーバーロードを呼び出して、日付を文字列形式に ToString(String, IFormatProvider) 変換 String.Format(IFormatProvider, String, Object[]) します。 引数として を指定して、インバリアント カルチャの書式設定 CultureInfo.InvariantCulture 規則を使用 provider します。 "O" または "R" 標準書式指定文字列を使用して、値をラウンドトリップする必要がある場合に指定します。

データを失わずに永続 DateTime 化された値を復元するには、次の手順に従います。

  1. または オーバーロードを呼び出して、データ ParseExactTryParseExact 解析します。 引数として を指定し、変換時に引数に使用したのと同じ CultureInfo.InvariantCulture provider 標準 format 書式指定文字列を使用します。 引数に DateTimeStyles.RoundtripKind 値を含 styles める。
  2. 値が時間内の 1 つの瞬間を表す場合は、 メソッドを呼び出して、解析された日付を UTC から DateTime ToLocalTime 現地時刻に変換します。

次の例では、インバリアント カルチャと "O" 標準書式指定文字列を使用して、ソース システムとターゲット システムのシステム、カルチャ、またはタイム ゾーンに関係なく、保存および復元された値が同じ時刻を表します。 DateTime

public static void PersistAsInvariantStrings()
{
    SaveDatesAsInvariantStrings();
    RestoreDatesAsInvariantStrings();
}

private static void SaveDatesAsInvariantStrings()
{
    DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
                   new DateTime(2014, 7, 10, 23, 49, 0),
                   new DateTime(2015, 1, 10, 1, 16, 0),
                   new DateTime(2014, 12, 20, 21, 45, 0),
                   new DateTime(2014, 6, 2, 15, 14, 0) };
    string output = null;

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        output += dates[ctr].ToUniversalTime().ToString("O", CultureInfo.InvariantCulture)
                  + (ctr != dates.Length - 1 ? "|" : "");
    }
    var sw = new StreamWriter(filenameTxt);
    sw.Write(output);
    sw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreDatesAsInvariantStrings()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine("Current Time Zone: {0}",
                      TimeZoneInfo.Local.DisplayName);
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    StreamReader sr = new StreamReader(filenameTxt);
    string[] inputValues = sr.ReadToEnd().Split(new char[] { '|' },
                                                StringSplitOptions.RemoveEmptyEntries);
    sr.Close();
    Console.WriteLine("The dates on an {0} system:",
                      Thread.CurrentThread.CurrentCulture.Name);
    foreach (var inputValue in inputValues)
    {
        DateTime dateValue;
        if (DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture,
                              DateTimeStyles.RoundtripKind, out dateValue))
        {
            Console.WriteLine($"'{inputValue}' --> {dateValue.ToLocalTime():f}");
        }
        else
        {
            Console.WriteLine("Cannot parse '{0}'", inputValue);
        }
    }
    Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       '2014-06-14T13:32:00.0000000Z' --> 14 June 2014 14:32
//       '2014-07-11T06:49:00.0000000Z' --> 11 July 2014 07:49
//       '2015-01-10T09:16:00.0000000Z' --> 10 January 2015 09:16
//       '2014-12-21T05:45:00.0000000Z' --> 21 December 2014 05:45
//       '2014-06-02T22:14:00.0000000Z' --> 02 June 2014 23:14
//       Restored dates...
Public Sub PersistAsInvariantStrings()
    SaveDatesAsInvariantStrings()
    RestoreDatesAsInvariantStrings()
End Sub

Private Sub SaveDatesAsInvariantStrings()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim output As String = Nothing

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        output += dates(ctr).ToUniversalTime().ToString("O", CultureInfo.InvariantCulture) +
                                   If(ctr <> dates.Length - 1, "|", "")
    Next
    Dim sw As New StreamWriter(filenameTxt)
    sw.Write(output)
    sw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsInvariantStrings()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine("Current Time Zone: {0}",
                    TimeZoneInfo.Local.DisplayName)
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim sr As New StreamReader(filenameTxt)
    Dim inputValues As String() = sr.ReadToEnd().Split({"|"c}, StringSplitOptions.RemoveEmptyEntries)
    sr.Close()
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each inputValue In inputValues
        Dim dateValue As Date
        If DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture,
                          DateTimeStyles.RoundtripKind, dateValue) Then
            Console.WriteLine($"'{inputValue}' --> {dateValue.ToLocalTime():f}")
        Else
            Console.WriteLine($"Cannot parse '{inputValue}'")
        End If
    Next
    Console.WriteLine("Restored dates...")
End Sub
' When saved on an en-US system, the example displays the following output:
'       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
'       The dates on an en-US system:
'       Saturday, June 14, 2014 6:32 AM
'       Thursday, July 10, 2014 11:49 PM
'       Saturday, January 10, 2015 1:16 AM
'       Saturday, December 20, 2014 9:45 PM
'       Monday, June 02, 2014 3:14 PM
'       Saved dates...
'
' When restored on an en-GB system, the example displays the following output:
'       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
'       The dates on an en-GB system:
'       '2014-06-14T13:32:00.0000000Z' --> 14 June 2014 14:32
'       '2014-07-11T06:49:00.0000000Z' --> 11 July 2014 07:49
'       '2015-01-10T09:16:00.0000000Z' --> 10 January 2015 09:16
'       '2014-12-21T05:45:00.0000000Z' --> 21 December 2014 05:45
'       '2014-06-02T22:14:00.0000000Z' --> 02 June 2014 23:14
'       Restored dates...
整数としての値の永続化

日付と時刻は、ティック数を Int64 表す値として保持できます。 この場合は、値が永続化および復元されるシステムのカルチャ DateTime を考慮する必要があります。

値を DateTime 整数として保持するには:

  • 値が DateTime 1 つの時間を表す場合は、 メソッドを呼び出して UTC に変換 ToUniversalTime します。
  • プロパティから値によって表されるティック DateTime 数を取得 Ticks します。

整数として DateTime 永続化された値を復元するには:

  1. コンストラクターに値を DateTime 渡して、新 Int64 しい オブジェクトをインスタンス化 DateTime(Int64) します。
  2. 値が 1 つの時刻を表す場合は、 メソッドを呼び出して UTC から DateTime 現地時刻に変換 ToLocalTime します。

次の例では、米国太平洋タイム ゾーン内のシステムで値の配列を DateTime 整数として保持します。 UTC ゾーン内のシステムで復元されます。 整数を含むファイルには、その直後の値の総数を Int32 示す Int64 値が含まれています。

public static void PersistAsIntegers()
{
    SaveDatesAsInts();
    RestoreDatesAsInts();
}

private static void SaveDatesAsInts()
{
    DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
                   new DateTime(2014, 7, 10, 23, 49, 0),
                   new DateTime(2015, 1, 10, 1, 16, 0),
                   new DateTime(2014, 12, 20, 21, 45, 0),
                   new DateTime(2014, 6, 2, 15, 14, 0) };

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    var ticks = new long[dates.Length];
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        ticks[ctr] = dates[ctr].ToUniversalTime().Ticks;
    }
    var fs = new FileStream(filenameInts, FileMode.Create);
    var bw = new BinaryWriter(fs);
    bw.Write(ticks.Length);
    foreach (var tick in ticks)
        bw.Write(tick);

    bw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreDatesAsInts()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    FileStream fs = new FileStream(filenameInts, FileMode.Open);
    BinaryReader br = new BinaryReader(fs);
    int items;
    DateTime[] dates;

    try
    {
        items = br.ReadInt32();
        dates = new DateTime[items];

        for (int ctr = 0; ctr < items; ctr++)
        {
            long ticks = br.ReadInt64();
            dates[ctr] = new DateTime(ticks).ToLocalTime();
        }
    }
    catch (EndOfStreamException)
    {
        Console.WriteLine("File corruption detected. Unable to restore data...");
        return;
    }
    catch (IOException)
    {
        Console.WriteLine("Unspecified I/O error. Unable to restore data...");
        return;
    }
    // Thrown during array initialization.
    catch (OutOfMemoryException)
    {
        Console.WriteLine("File corruption detected. Unable to restore data...");
        return;
    }
    finally
    {
        br.Close();
    }

    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    foreach (var value in dates)
        Console.WriteLine(value.ToString("f"));

    Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       14 June 2014 14:32
//       11 July 2014 07:49
//       10 January 2015 09:16
//       21 December 2014 05:45
//       02 June 2014 23:14
//       Restored dates...
Public Sub PersistAsIntegers()
    SaveDatesAsIntegers()
    RestoreDatesAsIntegers()
End Sub

Private Sub SaveDatesAsIntegers()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    Dim ticks(dates.Length - 1) As Long
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        ticks(ctr) = dates(ctr).ToUniversalTime().Ticks
    Next
    Dim fs As New FileStream(filenameInts, FileMode.Create)
    Dim bw As New BinaryWriter(fs)
    bw.Write(ticks.Length)
    For Each tick In ticks
        bw.Write(tick)
    Next
    bw.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesAsIntegers()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
    Dim fs As New FileStream(filenameInts, FileMode.Open)
    Dim br As New BinaryReader(fs)
    Dim items As Integer
    Dim dates As DateTime()

    Try
        items = br.ReadInt32()
        ReDim dates(items - 1)

        For ctr As Integer = 0 To items - 1
            Dim ticks As Long = br.ReadInt64()
            dates(ctr) = New DateTime(ticks).ToLocalTime()
        Next
    Catch e As EndOfStreamException
        Console.WriteLine("File corruption detected. Unable to restore data...")
        Exit Sub
    Catch e As IOException
        Console.WriteLine("Unspecified I/O error. Unable to restore data...")
        Exit Sub
    Catch e As OutOfMemoryException     'Thrown in array initialization.
        Console.WriteLine("File corruption detected. Unable to restore data...")
        Exit Sub
    Finally
        br.Close()
    End Try

    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each value In dates
        Console.WriteLine(value.ToString("f"))
    Next
    Console.WriteLine("Restored dates...")
End Sub
' When saved on an en-US system, the example displays the following output:
'       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
'       The dates on an en-US system:
'       Saturday, June 14, 2014 6:32 AM
'       Thursday, July 10, 2014 11:49 PM
'       Saturday, January 10, 2015 1:16 AM
'       Saturday, December 20, 2014 9:45 PM
'       Monday, June 02, 2014 3:14 PM
'       Saved dates...
'
' When restored on an en-GB system, the example displays the following output:
'       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
'       The dates on an en-GB system:
'       14 June 2014 14:32
'       11 July 2014 07:49
'       10 January 2015 09:16
'       21 December 2014 05:45
'       02 June 2014 23:14
'       Restored dates...

DateTime 値のシリアル化

ストリームまたはファイル DateTime へのシリアル化を使用して値を永続化し、逆シリアル化を使用して復元できます。 DateTime データは、指定されたオブジェクト形式でシリアル化されます。 オブジェクトは、逆シリアル化された場合に復元されます。 または などの書式指定子またはシリアライザーは、 XmlSerializer BinaryFormatter シリアル化と逆シリアル化のプロセスを処理します。 シリアル化の詳細と、シリアル化によってサポートされるシリアル化の種類については、「.NET Framework」を参照してください

次の例では、 クラス XmlSerializer を使用して値のシリアル化と逆シリアル化を行 DateTime います。 値は、21 世紀のすべての閏年日を表します。 現在のカルチャが英語 (英国) のシステムで例が実行されている場合、出力は結果を表します。 オブジェクト自体を逆シリアル化したので、コードは日付と時刻の形式の文化的な違いを処理 DateTime する必要はありません。

public static void PersistAsXML()
{
    // Serialize the data.
    var leapYears = new List<DateTime>();
    for (int year = 2000; year <= 2100; year += 4)
    {
        if (DateTime.IsLeapYear(year))
            leapYears.Add(new DateTime(year, 2, 29));
    }
    DateTime[] dateArray = leapYears.ToArray();

    var serializer = new XmlSerializer(dateArray.GetType());
    TextWriter sw = new StreamWriter(filenameXml);

    try
    {
        serializer.Serialize(sw, dateArray);
    }
    catch (InvalidOperationException e)
    {
        Console.WriteLine(e.InnerException.Message);
    }
    finally
    {
        if (sw != null) sw.Close();
    }

    // Deserialize the data.
    DateTime[] deserializedDates;
    using (var fs = new FileStream(filenameXml, FileMode.Open))
    {
        deserializedDates = (DateTime[])serializer.Deserialize(fs);
    }

    // Display the dates.
    Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    int nItems = 0;
    foreach (var dat in deserializedDates)
    {
        Console.Write($"   {dat:d}     ");
        nItems++;
        if (nItems % 5 == 0)
            Console.WriteLine();
    }
}
// The example displays the following output:
//    Leap year days from 2000-2100 on an en-GB system:
//       29/02/2000       29/02/2004       29/02/2008       29/02/2012       29/02/2016
//       29/02/2020       29/02/2024       29/02/2028       29/02/2032       29/02/2036
//       29/02/2040       29/02/2044       29/02/2048       29/02/2052       29/02/2056
//       29/02/2060       29/02/2064       29/02/2068       29/02/2072       29/02/2076
//       29/02/2080       29/02/2084       29/02/2088       29/02/2092       29/02/2096
Public Sub PersistAsXml()
    ' Serialize the data.
    Dim leapYears As New List(Of DateTime)()
    For year As Integer = 2000 To 2100 Step 4
        If Date.IsLeapYear(year) Then
            leapYears.Add(New Date(year, 2, 29))
        End If
    Next
    Dim dateArray As DateTime() = leapYears.ToArray()

    Dim serializer As New XmlSerializer(dateArray.GetType())
    Dim sw As TextWriter = New StreamWriter(filenameXml)

    Try
        serializer.Serialize(sw, dateArray)
    Catch e As InvalidOperationException
        Console.WriteLine(e.InnerException.Message)
    Finally
        If sw IsNot Nothing Then sw.Close()
    End Try

    ' Deserialize the data.
    Dim deserializedDates As Date()
    Using fs As New FileStream(filenameXml, FileMode.Open)
        deserializedDates = CType(serializer.Deserialize(fs), Date())
    End Using

    ' Display the dates.
    Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    Dim nItems As Integer
    For Each dat In deserializedDates
        Console.Write($"   {dat:d}     ")
        nItems += 1
        If nItems Mod 5 = 0 Then Console.WriteLine()
    Next
End Sub
' The example displays the following output:
'    Leap year days from 2000-2100 on an en-GB system:
'       29/02/2000       29/02/2004       29/02/2008       29/02/2012       29/02/2016
'       29/02/2020       29/02/2024       29/02/2028       29/02/2032       29/02/2036
'       29/02/2040       29/02/2044       29/02/2048       29/02/2052       29/02/2056
'       29/02/2060       29/02/2064       29/02/2068       29/02/2072       29/02/2076
'       29/02/2080       29/02/2084       29/02/2088       29/02/2092       29/02/2096

前の例には、時刻情報は含め" は含めなかった。 値が特定の時刻を表し、ローカル時刻として表される場合は、 メソッドを呼び出してシリアル化する前に、ローカル時刻から UTC に DateTime 変換 ToUniversalTime します。 逆シリアル化した後、 メソッドを呼び出して UTC からローカル時刻に変換 ToLocalTime します。 次の例では、 クラスを使用して、米国太平洋標準時ゾーン内のシステム上のデータをシリアル化し、米国中部標準ゾーンのシステム上で逆シリアル化します BinaryFormatter DateTime

public static void PersistBinary()
{
    SaveDatesBinary();
    RestoreDatesBinary();
}

private static void SaveDatesBinary()
{
    DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0),
                   new DateTime(2014, 7, 10, 23, 49, 0),
                   new DateTime(2015, 1, 10, 1, 16, 0),
                   new DateTime(2014, 12, 20, 21, 45, 0),
                   new DateTime(2014, 6, 2, 15, 14, 0) };
    var fs = new FileStream(filenameBin, FileMode.Create);
    var bin = new BinaryFormatter();

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        dates[ctr] = dates[ctr].ToUniversalTime();
    }
    bin.Serialize(fs, dates);
    fs.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreDatesBinary()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");

    FileStream fs = new FileStream(filenameBin, FileMode.Open);
    BinaryFormatter bin = new BinaryFormatter();
    var dates = (DateTime[])bin.Deserialize(fs);
    fs.Close();

    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    foreach (var value in dates)
        Console.WriteLine(value.ToLocalTime().ToString("f"));

    Console.WriteLine("Restored dates...");
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC-6:00) Central Time (US & Canada)
//       The dates on an en-GB system:
//       14 June 2014 08:32
//       11 July 2014 01:49
//       10 January 2015 03:16
//       20 December 2014 23:45
//       02 June 2014 17:14
//       Restored dates...
Public Sub PersistBinary()
    SaveDatesBinary()
    RestoreDatesBinary()
End Sub

Private Sub SaveDatesBinary()
    Dim dates As Date() = {#6/14/2014 6:32AM#, #7/10/2014 11:49PM#,
                          #1/10/2015 1:16AM#, #12/20/2014 9:45PM#,
                          #6/2/2014 3:14PM#}
    Dim fs As New FileStream(filenameBin, FileMode.Create)
    Dim bin As New BinaryFormatter()

    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Console.WriteLine("The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For ctr As Integer = 0 To dates.Length - 1
        Console.WriteLine(dates(ctr).ToString("f"))
        dates(ctr) = dates(ctr).ToUniversalTime()
    Next
    bin.Serialize(fs, dates)
    fs.Close()
    Console.WriteLine("Saved dates...")
End Sub

Private Sub RestoreDatesBinary()
    TimeZoneInfo.ClearCachedData()
    Console.WriteLine("Current Time Zone: {TimeZoneInfo.Local.DisplayName}")
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")

    Dim fs As New FileStream(filenameBin, FileMode.Open)
    Dim bin As New BinaryFormatter()
    Dim dates As DateTime() = DirectCast(bin.Deserialize(fs), Date())
    fs.Close()

    Console.WriteLine("The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:")
    For Each value In dates
        Console.WriteLine(value.ToLocalTime().ToString("f"))
    Next
    Console.WriteLine("Restored dates...")
End Sub
' When saved on an en-US system, the example displays the following output:
'       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
'       The dates on an en-US system:
'       Saturday, June 14, 2014 6:32 AM
'       Thursday, July 10, 2014 11:49 PM
'       Saturday, January 10, 2015 1:16 AM
'       Saturday, December 20, 2014 9:45 PM
'       Monday, June 02, 2014 3:14 PM
'       Saved dates...
'
' When restored on an en-GB system, the example displays the following output:
'       Current Time Zone: (UTC-6:00) Central Time (US & Canada)
'       The dates on an en-GB system:
'       14 June 2014 08:32
'       11 July 2014 01:49
'       10 January 2015 03:16
'       20 December 2014 11:45
'       02 June 2014 17:14
'       Restored dates...

DateTime データとタイム ゾーン データのシリアル化

前の例はすべて、値が DateTime ローカル時間として表されるという前提を持っています。 このコードでは、UTC とローカル時刻の間で値が変換され、ソース システムとターゲット システムで同じ時刻が反映されます。 DateTime 値は、ローカルおよび UTC 以外のタイム ゾーンの時刻を反映する場合があります。 構造体はタイム ゾーンに対応していないので、値とそのタイム ゾーンを表す オブジェクト DateTime DateTime の両方をシリアル TimeZoneInfo 化する必要があります。 フィールドに値とそのタイム ゾーンの両方が含 DateTime まれる型を作成します。 次の例では、 構造体を定義 DateWithTimeZone します。

using System;

namespace DateTimeExtensions
{
    [Serializable]
    public struct DateWithTimeZone
    {
        private TimeZoneInfo tz;
        private DateTime dt;

        public DateWithTimeZone(DateTime dateValue, TimeZoneInfo timeZone)
        {
            dt = dateValue;
            tz = timeZone ?? TimeZoneInfo.Local;
        }

        public TimeZoneInfo TimeZone
        {
            get { return (tz); }
            set { tz = value; }
        }

        public DateTime DateTime
        {
            get { return (dt); }
            set { dt = value; }
        }
    }
}
Namespace DateTimeExtensions
    <Serializable> Public Structure DateWithTimeZone
        Private tz As TimeZoneInfo
        Private dt As DateTime

        Public Sub New(dateValue As DateTime, timeZone As TimeZoneInfo)
            dt = dateValue
            tz = If(timeZone, TimeZoneInfo.Local)
        End Sub

        Public Property TimeZone As TimeZoneInfo
            Get
                Return tz
            End Get
            Set
                tz = Value
            End Set
        End Property

        Public Property DateTime As Date
            Get
                Return dt
            End Get
            Set
                dt = Value
            End Set
        End Property
    End Structure
End Namespace

重要

構造体は、オブジェクトの配列をシリアル化および逆シリアル化する次の 2 DateWithTimeZone つの例で使用 DateWithTimeZone されます。 この記事の例のセット全体のソースは、GitHub の docs リポジトリのVisual BasicまたはC#で確認できます。

構造体を使用 DateWithTimeZone すると、タイム ゾーン情報と共に日付と時刻を保持できます。 次の例では、 クラス BinaryFormatter を使用して、 オブジェクトの配列をシリアル化 DateWithTimeZone します。

public static void SaveDateWithTimeZone()
{
    DateWithTimeZone[] dates = { new DateWithTimeZone(new DateTime(2014, 8, 9, 19, 30, 0),
                              TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                          new DateWithTimeZone(new DateTime(2014, 8, 15, 19, 0, 0),
                              TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time")),
                          new DateWithTimeZone(new DateTime(2014, 8, 22, 19, 30, 0),
                              TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                          new DateWithTimeZone(new DateTime(2014, 8, 28, 19, 0, 0),
                              TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")) };
    var fs = new FileStream(@".\Schedule.bin", FileMode.Create);
    var formatter = new BinaryFormatter();
    try
    {
        formatter.Serialize(fs, dates);
        // Display dates.
        foreach (var date in dates)
        {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine($"{date.DateTime} {(tz.IsDaylightSavingTime(date.DateTime) ? tz.DaylightName : tz.StandardName)}");
        }
    }
    catch (SerializationException e)
    {
        Console.WriteLine($"Serialization failed. Reason: {e.Message}");
    }
    finally
    {
        if (fs != null) fs.Close();
    }
}
// The example displays the following output:
//       8/9/2014 7:30:00 PM Eastern Daylight Time
//       8/15/2014 7:00:00 PM Pacific Daylight Time
//       8/22/2014 7:30:00 PM Eastern Daylight Time
//       8/28/2014 7:00:00 PM Eastern Daylight Time
Public Sub SaveDateWithTimeZone()
    Dim dates As DateWithTimeZone() = {New DateWithTimeZone(#8/9/2014 7:30PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                                  New DateWithTimeZone(#8/15/2014 7:00PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time")),
                                  New DateWithTimeZone(#8/22/2014 7:30PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                                  New DateWithTimeZone(#8/28/2014 7:00PM#,
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time"))}
    Dim fs As New FileStream(".\Schedule.bin", FileMode.Create)
    Dim formatter As New BinaryFormatter()
    Try
        formatter.Serialize(fs, dates)
    Catch e As SerializationException
        Console.WriteLine($"Serialization failed. Reason: {e.Message}")
    Finally
        If fs IsNot Nothing Then fs.Close()
    End Try
    ' Display dates.
    For Each dateInfo In dates
        Dim tz As TimeZoneInfo = dateInfo.TimeZone
        Console.WriteLine($"{dateInfo.DateTime} {If(tz.IsDaylightSavingTime(dateInfo.DateTime), tz.DaylightName, tz.StandardName)}")
    Next
End Sub
' The example displays the following output:
'       8/9/2014 7:30:00 PM Eastern Daylight Time
'       8/15/2014 7:00:00 PM Pacific Daylight Time
'       8/22/2014 7:30:00 PM Eastern Daylight Time
'       8/28/2014 7:00:00 PM Eastern Daylight Time

次の例では、 メソッドを BinaryFormatter.Deserialize 呼び出して逆シリアル化します。

public static void RestoreDateWithTimeZone()
{
    const string filename = @".\Schedule.bin";
    FileStream fs;
    if (File.Exists(filename))
    {
        fs = new FileStream(filename, FileMode.Open);
    }
    else
    {
        Console.WriteLine("Unable to find file to deserialize.");
        return;
    }

    var formatter = new BinaryFormatter();
    DateWithTimeZone[] dates;
    try
    {
        dates = (DateWithTimeZone[])formatter.Deserialize(fs);
        // Display dates.
        foreach (var date in dates)
        {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine($"{ date.DateTime} {(tz.IsDaylightSavingTime(date.DateTime) ? tz.DaylightName : tz.StandardName)}");
        }
    }
    catch (SerializationException e)
    {
        Console.WriteLine($"Deserialization failed. Reason: {e.Message}");
    }
    finally
    {
        if (fs != null) fs.Close();
    }
}
// The example displays the following output:
//       8/9/2014 7:30:00 PM Eastern Daylight Time
//       8/15/2014 7:00:00 PM Pacific Daylight Time
//       8/22/2014 7:30:00 PM Eastern Daylight Time
//       8/28/2014 7:00:00 PM Eastern Daylight Time
Public Sub RestoreDateWithTimeZone()
    Dim fs As FileStream
    If File.Exists(filename) Then
        fs = New FileStream(filename, FileMode.Open)
    Else
        Console.WriteLine("Unable to find file to deserialize.")
        Exit Sub
    End If

    Dim formatter As New BinaryFormatter()
    Dim dates As DateWithTimeZone ()= Nothing
    Try
        dates = DirectCast(formatter.Deserialize(fs), DateWithTimeZone())
        ' Display dates.
        For Each dateInfo In dates
            Dim tz As TimeZoneInfo = dateInfo.TimeZone
            Console.WriteLine($"{dateInfo.DateTime} {If(tz.IsDaylightSavingTime(dateInfo.DateTime), tz.DaylightName, tz.StandardName)}")
        Next
    Catch e As SerializationException
        Console.WriteLine("Deserialization failed. Reason: {e.Message}")
    Finally
        If fs IsNot Nothing Then fs.Close()
    End Try
End Sub
' The example displays the following output:
'       8/9/2014 7:30:00 PM Eastern Daylight Time
'       8/15/2014 7:00:00 PM Pacific Daylight Time
'       8/22/2014 7:30:00 PM Eastern Daylight Time
'       8/28/2014 7:00:00 PM Eastern Daylight Time

DateTime と TimeSpan

と の値の型は、 が一定の時間を表すのに対し、 DateTime TimeSpan DateTime TimeSpan は時間間隔を表す点が異なります。 のインスタンスを別のインスタンスから減算して、その間の時間間隔を表す DateTime TimeSpan オブジェクトを取得できます。 または、現在の に正の TimeSpan 値を追加して、将来 DateTime の日付を表 DateTime す値を取得できます。

オブジェクトに対して時間間隔を加算または減算 DateTime できます。 時間間隔は負の値または正の値を指定できます。また、ティック、秒、オブジェクトなどの単位で表現 TimeSpan できます。

許容範囲内の等値の比較

値の等値比較 DateTime は正確です。 つまり、2 つの値は、等しいと見なされるのと同じティック数として表す必要があります。 多くの場合、多くのアプリケーションでは、その精度が不要な場合や正しくない場合があります。 多くの場合、オブジェクトが大ま DateTime かに等しい かテストする必要があります

次の例は、おおよそ同等の値を比較する方法を示 DateTime しています。 等しいと宣言するときに、小さな差の余白を受け取る。

public static bool RoughlyEquals(DateTime time, DateTime timeWithWindow, int windowInSeconds, int frequencyInSeconds)
{
    long delta = (long)((TimeSpan)(timeWithWindow - time)).TotalSeconds % frequencyInSeconds;
    delta = delta > windowInSeconds ? frequencyInSeconds - delta : delta;
    return Math.Abs(delta) < windowInSeconds;
}

public static void TestRoughlyEquals()
{
    int window = 10;
    int freq = 60 * 60 * 2; // 2 hours;

    DateTime d1 = DateTime.Now;

    DateTime d2 = d1.AddSeconds(2 * window);
    DateTime d3 = d1.AddSeconds(-2 * window);
    DateTime d4 = d1.AddSeconds(window / 2);
    DateTime d5 = d1.AddSeconds(-window / 2);

    DateTime d6 = (d1.AddHours(2)).AddSeconds(2 * window);
    DateTime d7 = (d1.AddHours(2)).AddSeconds(-2 * window);
    DateTime d8 = (d1.AddHours(2)).AddSeconds(window / 2);
    DateTime d9 = (d1.AddHours(2)).AddSeconds(-window / 2);

    Console.WriteLine($"d1 ({d1}) ~= d1 ({d1}): {RoughlyEquals(d1, d1, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d2 ({d2}): {RoughlyEquals(d1, d2, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d3 ({d3}): {RoughlyEquals(d1, d3, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d4 ({d4}): {RoughlyEquals(d1, d4, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d5 ({d5}): {RoughlyEquals(d1, d5, window, freq)}");

    Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d9 ({d9}): {RoughlyEquals(d1, d9, window, freq)}");
}
// The example displays output similar to the following:
//    d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True
Public Shared Function RoughlyEquals(time As DateTime, timeWithWindow As DateTime,
                             windowInSeconds As Integer,
                             frequencyInSeconds As Integer) As Boolean
    Dim delta As Long = (timeWithWindow.Subtract(time)).TotalSeconds _
                                            Mod frequencyInSeconds

    If delta > windowInSeconds Then
        delta = frequencyInSeconds - delta
    End If

    Return Math.Abs(delta) < windowInSeconds
End Function

Public Shared Sub TestRoughlyEquals()
    Dim window As Integer = 10
    Dim freq As Integer = 60 * 60 * 2 ' 2 hours;
    Dim d1 As DateTime = DateTime.Now

    Dim d2 As DateTime = d1.AddSeconds(2 * window)
    Dim d3 As DateTime = d1.AddSeconds(-2 * window)
    Dim d4 As DateTime = d1.AddSeconds(window / 2)
    Dim d5 As DateTime = d1.AddSeconds(-window / 2)

    Dim d6 As DateTime = d1.AddHours(2).AddSeconds(2 * window)
    Dim d7 As DateTime = d1.AddHours(2).AddSeconds(-2 * window)
    Dim d8 As DateTime = d1.AddHours(2).AddSeconds(window / 2)
    Dim d9 As DateTime = d1.AddHours(2).AddSeconds(-window / 2)

    Console.WriteLine($"d1 ({d1}) ~= d1 ({d1}): {RoughlyEquals(d1, d1, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d2 ({d2}): {RoughlyEquals(d1, d2, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d3 ({d3}): {RoughlyEquals(d1, d3, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d4 ({d4}): {RoughlyEquals(d1, d4, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d5 ({d5}): {RoughlyEquals(d1, d5, window, freq)}")

    Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d9 ({d9}): {RoughlyEquals(d1, d9, window, freq)}")
End Sub
' The example displays output similar to the following:
'    d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
'    d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
'    d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True

COM 相互運用に関する考慮事項

COM アプリケーションに転送された値は、マネージド アプリケーションに転送され、ラウンドトリップと DateTime 言います。 ただし、 DateTime 時刻のみを指定する値は、予想されるラウンドトリップではありません。

午後 3 時などの時刻のみをラウンドトリップする場合、最終的な日付と時刻は 1899 年 12 月 30 日 (C.E. 0001 年 1 月 1 日 (C.E. 午後 3 時 00 分 この.NET Framework COM では、時刻だけが指定されている場合、既定の日付が想定されます。 ただし、COM システムは 1899 年 12 月 30 日の基準日を想定し、.NET Framework では 0001 年 1 月 1 日の基準日を想定しています。

特定の時刻から COM に.NET Framework場合、時刻を COM で使用される形式に変換する特別な処理が実行されます。 COM から .NET Framework に時刻が渡された場合、1899 年 12 月 30 日以前の正当な日付と時刻が破損する特殊な処理は実行されません。 日付が COM からラウンドトリップを開始する場合、日付.NET Framework COM は日付を保持します。

.NET Framework と COM の動作は、アプリケーションが時刻のみを指定する をラウンドトリップする場合、アプリケーションが最後のオブジェクトの誤った日付を変更または無視することを忘らなければならないことを意味します DateTime DateTime

コンストラクター

DateTime(Int32, Int32, Int32)

DateTime 構造体の新しいインスタンスを、指定した年、月、日に初期化します。

DateTime(Int32, Int32, Int32, Calendar)

DateTime 構造体の新しいインスタンスを、指定した暦の指定した年、月、および日に初期化します。

DateTime(Int32, Int32, Int32, Int32, Int32, Int32)

DateTime 構造体の新しいインスタンスを、指定した年、月、日、時、分、および秒に初期化します。

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

DateTime 構造体の新しいインスタンスを、指定した暦の指定した年、月、日、時、分、および秒に初期化します。

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

DateTime 構造体の新しいインスタンスを、指定した年、月、日、時、分、秒、および世界協定時刻 (UTC) または現地時刻に初期化します。

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32)

DateTime 構造体の新しいインスタンスを、指定した年、月、日、時、分、秒、およびミリ秒に初期化します。

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

DateTime 構造体の新しいインスタンスを、指定した暦の指定した年、月、日、時、分、秒、およびミリ秒に初期化します。

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)

DateTime 構造体の新しいインスタンスを、指定した暦の指定した年、月、日、時、分、秒、ミリ秒、および世界協定時刻 (UTC) または現地時刻に初期化します。

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

DateTime 構造体の新しいインスタンスを、指定した年、月、日、時、分、秒、ミリ秒、および世界協定時刻 (UTC) または現地時刻に初期化します。

DateTime(Int64)

DateTime 構造体の新しいインスタンスを、指定したタイマー刻み数に初期化します。

DateTime(Int64, DateTimeKind)

DateTime 構造体の新しいインスタンスを、指定したタイマー刻み数と世界協定時刻 (UTC) または現地時刻に初期化します。

フィールド

MaxValue

DateTime の最大有効値を表します。 このフィールドは読み取り専用です。

MinValue

DateTime の最小有効値を表します。 このフィールドは読み取り専用です。

UnixEpoch

この定数の値は、グレゴリオ暦での 1970 年 1 月 1 日 00:00:00.0000000 UTC に相当します。 UnixEpoch によって、UNIX 時刻が 0 に等しい特定の時点が定義されます。

プロパティ

Date

このインスタンスの日付の部分を取得します。

Day

このインスタンスで表される月の日付を取得します。

DayOfWeek

このインスタンスで表される曜日を取得します。

DayOfYear

このインスタンスで表される年間積算日を取得します。

Hour

このインスタンスで表される日付の時間の部分を取得します。

Kind

このインスタンスが表す時刻の種類 (現地時刻、世界協定時刻 (UTC)、または、そのどちらでもない) を示す値を取得します。

Millisecond

このインスタンスで表される日付のミリ秒の部分を取得します。

Minute

このインスタンスで表される日付の分の部分を取得します。

Month

このインスタンスで表される日付の月の部分を取得します。

Now

コンピューター上の現在の日時を現地時刻で表した DateTime オブジェクトを取得します。

Second

このインスタンスで表される日付の秒の部分を取得します。

Ticks

このインスタンスの日付と時刻を表すタイマー刻み数を取得します。

TimeOfDay

このインスタンスの時刻を取得します。

Today

現在の日付を取得します。

UtcNow

コンピューター上の現在の日時を世界協定時刻 (UTC) で表した DateTime オブジェクトを取得します。

Year

このインスタンスで表される日付の年の部分を取得します。

メソッド

Add(TimeSpan)

このインスタンスの値に、指定された TimeSpan の値を加算した新しい DateTime を返します。

AddDays(Double)

このインスタンスの値に、指定された日数を加算した新しい DateTime を返します。

AddHours(Double)

このインスタンスの値に、指定された時間数を加算した新しい DateTime を返します。

AddMilliseconds(Double)

このインスタンスの値に、指定されたミリ秒数を加算した新しい DateTime を返します。

AddMinutes(Double)

このインスタンスの値に、指定された分数を加算した新しい DateTime を返します。

AddMonths(Int32)

このインスタンスの値に、指定された月数を加算した新しい DateTime を返します。

AddSeconds(Double)

このインスタンスの値に、指定された秒数を加算した新しい DateTime を返します。

AddTicks(Int64)

このインスタンスの値に、指定されたタイマー刻みの数を加算した新しい DateTime を返します。

AddYears(Int32)

このインスタンスの値に、指定された年数を加算した新しい DateTime を返します。

Compare(DateTime, DateTime)

DateTime の 2 つのインスタンスを比較し、第 1 のインスタンスが第 2 のインスタンスよりも前か、同じか、それとも後かを示す整数を返します。

CompareTo(DateTime)

このインスタンスの値と指定した DateTime の値を比較し、このインスタンスの値が指定した DateTime の値よりも前か、同じか、または後かを示す整数を返します。

CompareTo(Object)

このインスタンスの値と指定した DateTime の値を含む指定したオブジェクトを比較し、このインスタンスの値が指定した DateTime の値よりも前か、同じか、または後かを示す整数を返します。

DaysInMonth(Int32, Int32)

指定した月および年の日数を返します。

Equals(DateTime)

このインスタンスの値が、指定した DateTime インスタンスの値と等しいかどうかを示す値を返します。

Equals(DateTime, DateTime)

DateTime の 2 つのインスタンスが同じ日付/時刻値を持っているかどうかを示す値を返します。

Equals(Object)

このインスタンスが指定されたオブジェクトに等しいかどうかを示す値を返します。

FromBinary(Int64)

64 ビットのバイナリ値を逆シリアル化し、元のシリアル化 DateTime オブジェクトを再構築します。

FromFileTime(Int64)

指定された Windows ファイル時刻を同等の現地時刻に変換します。

FromFileTimeUtc(Int64)

指定された Windows ファイル時刻を同等の UTC 時刻に変換します。

FromOADate(Double)

指定した OLE オートメーション日付と等しい DateTime を返します。

GetDateTimeFormats()

このインスタンスの値を、標準の日時形式指定子によってサポートされるすべての文字列形式に変換します。

GetDateTimeFormats(Char)

このインスタンスの値を、指定した標準の日時形式指定子によってサポートされるすべての文字列表記に変換します。

GetDateTimeFormats(Char, IFormatProvider)

このインスタンスの値を、指定した標準日時形式指定子およびカルチャ固有の書式情報によってサポートされる、すべての文字列形式に変換します。

GetDateTimeFormats(IFormatProvider)

このインスタンスの値を、標準日時形式指定子および指定したカルチャ固有の書式情報によってサポートされる、すべての文字列形式に変換します。

GetHashCode()

このインスタンスのハッシュ コードを返します。

GetTypeCode()

DateTime 値型の TypeCode を返します。

IsDaylightSavingTime()

DateTime のインスタンスが、現在のタイム ゾーンの夏時間の期間内であるかどうかを示します。

IsLeapYear(Int32)

指定された年が閏年かどうかを示す値を返します。

Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

カルチャ固有の書式情報と書式スタイルを使用して、日付と時刻の文字列形式を含むメモリ範囲を等価の DateTime に変換します。

Parse(String)

現在のスレッド カルチャの書式規則を使用して、日付と時刻の文字列形式を等価の DateTime に変換します。

Parse(String, IFormatProvider)

カルチャ固有の書式情報を使用して、日付と時刻の文字列形式を等価の DateTime に変換します。

Parse(String, IFormatProvider, DateTimeStyles)

カルチャ固有の書式情報と書式スタイルを使用して、日付と時刻の文字列形式を等価の DateTime に変換します。

ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)

指定した書式、カルチャ固有の書式情報、スタイルを使用して、指定した日付と時刻のスパン表現を、それと等価な DateTime に変換します。 文字列形式の書式は、指定した書式と完全に一致する必要があります。それ以外の場合は、例外がスローされます。

ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)

指定した書式の配列、カルチャ固有の書式情報、スタイルを使用して、指定した日付と時刻のスパン表現を、それと等価な DateTime に変換します。 文字列形式の書式は、指定した書式の少なくとも 1 つと完全に一致する必要があります。それ以外の場合は、例外がスローされます。

ParseExact(String, String, IFormatProvider)

指定した書式とカルチャ固有の書式情報を使用して、指定した日付と時刻の文字列形式を等価の DateTime の値に変換します。 文字列形式の書式は、指定した書式と完全に一致する必要があります。

ParseExact(String, String, IFormatProvider, DateTimeStyles)

指定した書式、カルチャ固有の書式情報、およびスタイルを使用して、指定した日付と時刻の文字列形式を等価の DateTime に変換します。 文字列形式の書式は、指定した書式と完全に一致する必要があります。それ以外の場合は、例外がスローされます。

ParseExact(String, String[], IFormatProvider, DateTimeStyles)

指定した書式の配列、カルチャ固有の書式情報、およびスタイルを使用して、指定した日付と時刻の文字列形式を等価の DateTime に変換します。 文字列形式の書式は、指定した書式の少なくとも 1 つと完全に一致する必要があります。それ以外の場合は、例外がスローされます。

SpecifyKind(DateTime, DateTimeKind)

指定された DateTime と同じタイマー刻みの数を持つ新しい DateTime オブジェクトを、指定された DateTimeKind 値 (現地時刻、世界協定時刻 (UTC)、または、そのいずれでもないことを示す) に基づいて作成します。

Subtract(DateTime)

このインスタンスの値から指定した日時を減算した、新しい TimeSpan を返します。

Subtract(TimeSpan)

このインスタンスの値から指定した期間を減算した、新しい DateTime を返します。

ToBinary()

現在の DateTime オブジェクトを 64 ビットのバイナリ値にシリアル化します。後で、この値を使って、DateTime オブジェクトを再構築できます。

ToFileTime()

現在の DateTime オブジェクトの値を Windows ファイル時刻に変換します。

ToFileTimeUtc()

現在の DateTime オブジェクトの値を Windows ファイル時刻に変換します。

ToLocalTime()

現在の DateTime オブジェクトの値を現地時刻に変換します。

ToLongDateString()

現在の DateTime オブジェクトの値を、それと等価な長い形式の日付の文字列形式に変換します。

ToLongTimeString()

現在の DateTime オブジェクトの値を、それと等価な長い形式の時刻の文字列形式に変換します。

ToOADate()

このインスタンスの値をそれと等価な OLE オートメーション日付に変換します。

ToShortDateString()

現在の DateTime オブジェクトの値を、それと等価な短い形式の日付の文字列形式に変換します。

ToShortTimeString()

現在の DateTime オブジェクトの値を、それと等価な短い形式の時刻の文字列形式に変換します。

ToString()

現在のカルチャの書式指定規則を使用して、現在の DateTime オブジェクトの値をそれと等価な文字列形式に変換します。

ToString(IFormatProvider)

指定したカルチャ固有の書式情報を使用して、現在の DateTime オブジェクトの値をそれと等価な文字列形式に変換します。

ToString(String)

指定した形式および現在のカルチャの書式指定規則を使用して、現在の DateTime オブジェクトの値をそれと等価な文字列形式に変換します。

ToString(String, IFormatProvider)

指定した書式およびカルチャ固有の書式情報を使用して、現在の DateTime オブジェクトの値をそれと等価の文字列形式に変換します。

ToUniversalTime()

現在の DateTime オブジェクトの値を世界協定時刻 (UTC) に変換します。

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

現在の DateTime 型のインスタンスの値を、指定した文字スパンに書式設定しようとします。

TryParse(ReadOnlySpan<Char>, DateTime)

指定した日付と時刻の文字スパンを、それと等価な DateTime に変換し、変換が成功したかどうかを示す値を返します。

TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)

指定したカルチャ固有の書式情報と書式スタイルを使用して、日付と時刻のスパン表現を、それと等価な DateTime に変換し、変換が成功したかどうかを示す値を返します。

TryParse(String, DateTime)

指定した文字列形式の日時を対応する DateTime 表現に変換し、変換に成功したかどうかを示す値を返します。

TryParse(String, IFormatProvider, DateTimeStyles, DateTime)

指定したカルチャ固有の書式情報と書式スタイルを使用して、指定した文字列形式の日付と時刻をそれと等価の DateTime に変換し、変換に成功したかどうかを示す値を返します。

TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)

指定した書式、カルチャ固有の書式情報、スタイルを使用して、指定した日付と時刻のスパン表現を、それと等価な DateTime に変換します。 文字列形式の書式は、指定した書式と完全に一致する必要があります。 このメソッドは、変換に成功したかどうかを示す値を返します。

TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTime)

指定した日付と時刻の文字スパンを、それと等価な DateTime に変換し、変換が成功したかどうかを示す値を返します。

TryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)

指定した書式、カルチャ固有の書式情報、およびスタイルを使用して、指定した日付と時刻の文字列形式を等価の DateTime に変換します。 文字列形式の書式は、指定した書式と完全に一致する必要があります。 このメソッドは、変換に成功したかどうかを示す値を返します。

TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime)

指定した書式の配列、カルチャ固有の書式情報、およびスタイルを使用して、指定した日付と時刻の文字列形式を等価の DateTime に変換します。 文字列形式の書式は、指定した書式の少なくとも 1 つと完全に一致する必要があります。 このメソッドは、変換に成功したかどうかを示す値を返します。

演算子

Addition(DateTime, TimeSpan)

指定した日付と時刻に指定した時間間隔を加算して、新しい日付と時刻を作成します。

Equality(DateTime, DateTime)

DateTime の 2 つの指定したインスタンスが等しいかどうかを判断します。

GreaterThan(DateTime, DateTime)

指定した DateTime が、指定したもう 1 つの DateTime より後の時刻かどうかを判断します。

GreaterThanOrEqual(DateTime, DateTime)

指定した 1 つの DateTime が、指定した別の DateTime と同じ日時またはそれより後の日時を表しているかどうかを判断します。

Inequality(DateTime, DateTime)

DateTime の 2 つの指定したインスタンスが等しいかどうかを判断します。

LessThan(DateTime, DateTime)

指定した DateTime が、指定したもう 1 つの DateTime より前の時刻かどうかを判断します。

LessThanOrEqual(DateTime, DateTime)

指定した 1 つの DateTime が、指定した別の DateTime と同じ日時またはそれより前の日時を表しているかどうかを判断します。

Subtraction(DateTime, DateTime)

指定した日付と時刻から指定したもう 1 つの日付と時刻を減算して、時間間隔を返します。

Subtraction(DateTime, TimeSpan)

指定した日付と時刻から指定した時間間隔を減算して、新しい日付と時刻を返します。

明示的なインターフェイスの実装

IComparable.CompareTo(Object)

現在のインスタンスを同じ型の別のオブジェクトと比較し、現在のインスタンスの並べ替え順序での位置が、比較対象のオブジェクトと比べて前か、後か、または同じかを示す整数を返します。

IConvertible.GetTypeCode()

インスタンスの TypeCode を返します。

IConvertible.ToBoolean(IFormatProvider)

この変換はサポートされていません。 このメソッドを使用しようとすると、InvalidCastException がスローされます。

IConvertible.ToByte(IFormatProvider)

この変換はサポートされていません。 このメソッドを使用しようとすると、InvalidCastException がスローされます。

IConvertible.ToChar(IFormatProvider)

この変換はサポートされていません。 このメソッドを使用しようとすると、InvalidCastException がスローされます。

IConvertible.ToDateTime(IFormatProvider)

現在の DateTime オブジェクトを返します。

IConvertible.ToDecimal(IFormatProvider)

この変換はサポートされていません。 このメソッドを使用しようとすると、InvalidCastException がスローされます。

IConvertible.ToDouble(IFormatProvider)

この変換はサポートされていません。 このメソッドを使用しようとすると、InvalidCastException がスローされます。

IConvertible.ToInt16(IFormatProvider)

この変換はサポートされていません。 このメソッドを使用しようとすると、InvalidCastException がスローされます。

IConvertible.ToInt32(IFormatProvider)

この変換はサポートされていません。 このメソッドを使用しようとすると、InvalidCastException がスローされます。

IConvertible.ToInt64(IFormatProvider)

この変換はサポートされていません。 このメソッドを使用しようとすると、InvalidCastException がスローされます。

IConvertible.ToSByte(IFormatProvider)

この変換はサポートされていません。 このメソッドを使用しようとすると、InvalidCastException がスローされます。

IConvertible.ToSingle(IFormatProvider)

この変換はサポートされていません。 このメソッドを使用しようとすると、InvalidCastException がスローされます。

IConvertible.ToType(Type, IFormatProvider)

現在の DateTime オブジェクトを、指定された型のオブジェクトに変換します。

IConvertible.ToUInt16(IFormatProvider)

この変換はサポートされていません。 このメソッドを使用しようとすると、InvalidCastException がスローされます。

IConvertible.ToUInt32(IFormatProvider)

この変換はサポートされていません。 このメソッドを使用しようとすると、InvalidCastException がスローされます。

IConvertible.ToUInt64(IFormatProvider)

この変換はサポートされていません。 このメソッドを使用しようとすると、InvalidCastException がスローされます。

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

SerializationInfo オブジェクトに、現在の DateTime オブジェクトをシリアル化するために必要なすべてのデータを格納します。

適用対象

スレッド セーフ

この型のすべてのメンバーはスレッド セーフです。 インスタンスの状態を変更すると思えるメンバーは、実際には新しい値で初期化された新しいインスタンスを返します。 他の型と同様に、この型のインスタンスを含む共有変数の読み取りおよび書き込みは、スレッドセーフを保証するためにロックによって保護する必要があります。

こちらもご覧ください