【C#】Parse・ParseExact・TryParseで文字列をDateTimeに変換する基本と実践テクニック

using System;
class Program
{
    static void Main()
    {
        string validDate = "2023-06-15";
        string invalidDate = "invalid-date";
        // DateTime.Parseは例外をスローする可能性がある
        try
        {
            DateTime parsedDate = DateTime.Parse(validDate);
            Console.WriteLine($"Parse成功: {parsedDate}");
            parsedDate = DateTime.Parse(invalidDate); // 例外発生
        }
        catch (FormatException)
        {
            Console.WriteLine("Parseで変換に失敗しました。");
        }
        // DateTime.TryParseは例外をスローしない
        if (DateTime.TryParse(validDate, out DateTime tryParsedDate))
        {
            Console.WriteLine($"TryParse成功: {tryParsedDate}");
        }
        else
        {
            Console.WriteLine("TryParseで変換に失敗しました。");
        }
        if (!DateTime.TryParse(invalidDate, out _))
        {
            Console.WriteLine("TryParseで無効な文字列を検出しました。");
        }
    }
}

Parse成功: 2023/06/15 0:00:00
Parseで変換に失敗しました。
TryParse成功: 2023/06/15 0:00:00
TryParseで無効な文字列を検出しました。

DateTime now = DateTime.Now;
Console.WriteLine(now.ToString("d")); // 例: 2024/06/15 (日本ロケール)
Console.WriteLine(now.ToString("D")); // 例: 2024年6月15日土曜日
Console.WriteLine(now.ToString("o")); // 例: 2024-06-15T14:30:00.0000000

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string dateString = "2024年6月15日";
        string format = "yyyy年M月d日";
        DateTime date = DateTime.ParseExact(dateString, format, CultureInfo.InvariantCulture);
        Console.WriteLine(date); // 出力: 2024/06/15 0:00:00
    }
}

using System;
class Program
{
    static void Main()
    {
        string dateString = "2024-06-15";
        DateTime date = DateTime.Parse(dateString);
        Console.WriteLine(date); // 出力: 2024/06/15 0:00:00
    }
}

2024/06/15 0:00:00

using System;
class Program
{
    static void Main()
    {
        string dateString = "June 15, 2024";
        DateTime date = DateTime.Parse(dateString);
        Console.WriteLine(date); // 出力: 2024/06/15 0:00:00
    }
}

2024/06/15 0:00:00

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string jpDate = "1月15日, 2024";
        DateTime dateJP = DateTime.Parse(jpDate, CultureInfo.CurrentCulture);
        Console.WriteLine(dateJP); // 日本環境なら成功
        string enDate = "January 15, 2024";
        DateTime dateEN = DateTime.Parse(enDate, CultureInfo.InvariantCulture);
        Console.WriteLine(dateEN); // InvariantCultureで成功
    }
}

2024/01/15 0:00:00
2024/01/15 0:00:00

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string ambiguousDate = "01/02/03";
        DateTime dateJP = DateTime.Parse(ambiguousDate, new CultureInfo("ja-JP"));
        Console.WriteLine($"ja-JP: {dateJP:yyyy/MM/dd}");
        DateTime dateUS = DateTime.Parse(ambiguousDate, new CultureInfo("en-US"));
        Console.WriteLine($"en-US: {dateUS:yyyy/MM/dd}");
    }
}

ja-JP: 2001/02/03
en-US: 2003/01/02

string invalidDate = "2024-13-01"; // 13月は存在しない
DateTime.Parse(invalidDate); // FormatException発生

string jpDate = "1月15日, 2024";
DateTime.Parse(jpDate, new CultureInfo("en-US")); // 失敗

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string date1 = "2024/6/5";
        string date2 = "2024/06/05";
        string format = "yyyy/M/d";
        DateTime dt1 = DateTime.ParseExact(date1, format, CultureInfo.InvariantCulture);
        DateTime dt2 = DateTime.ParseExact(date2, format, CultureInfo.InvariantCulture);
        Console.WriteLine(dt1); // 2024/06/05 0:00:00
        Console.WriteLine(dt2); // 2024/06/05 0:00:00
    }
}

2024/06/05 0:00:00
2024/06/05 0:00:00

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string[] formats = { "yyyy/MM/dd", "yyyy-M-d", "yyyyMMdd" };
        string[] dates = { "2024/06/15", "2024-6-15", "20240615" };
        foreach (var dateStr in dates)
        {
            DateTime dt = DateTime.ParseExact(dateStr, formats, CultureInfo.InvariantCulture, DateTimeStyles.None);
            Console.WriteLine(dt.ToString("yyyy-MM-dd"));
        }
    }
}

2024-06-15
2024-06-15
2024-06-15

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string dateStr = "2024-06-15 14:30:05.123";
        string format = "yyyy-MM-dd HH:mm:ss.fff";
        DateTime dt = DateTime.ParseExact(dateStr, format, CultureInfo.InvariantCulture);
        Console.WriteLine(dt.ToString("yyyy-MM-dd HH:mm:ss.fff"));
    }
}

2024-06-15 14:30:05.123

using System;
class Program
{
    static void Main()
    {
        string[] inputs = { "2024-06-15", "invalid-date", "06/15/2024" };
        foreach (var input in inputs)
        {
            if (DateTime.TryParse(input, out DateTime result))
            {
                Console.WriteLine($"変換成功: {result:yyyy-MM-dd}");
            }
            else
            {
                Console.WriteLine($"変換失敗: {input}");
            }
        }
    }
}

変換成功: 2024-06-15
変換失敗: invalid-date
変換成功: 2024-06-15

using System;
class Program
{
    static DateTime? ParseToNullableDate(string input)
    {
        if (DateTime.TryParse(input, out DateTime date))
        {
            return date;
        }
        return null;
    }
    static void Main()
    {
        string[] inputs = { "2024-06-15", "invalid-date" };
        foreach (var input in inputs)
        {
            DateTime? date = ParseToNullableDate(input);
            if (date.HasValue)
            {
                Console.WriteLine($"変換成功: {date.Value:yyyy-MM-dd}");
            }
            else
            {
                Console.WriteLine($"変換失敗: {input}");
            }
        }
    }
}

変換成功: 2024-06-15
変換失敗: invalid-date

using System;
class Program
{
    static bool IsValidDateString(string input)
    {
        // ここで入力の基本的な検証を行う(例: 空文字や特定のパターンチェック)
        return !string.IsNullOrWhiteSpace(input);
    }
    static DateTime? ConvertToDate(string input)
    {
        if (!IsValidDateString(input))
        {
            return null;
        }
        if (DateTime.TryParse(input, out DateTime date))
        {
            return date;
        }
        return null;
    }
    static void Main()
    {
        string[] inputs = { "2024-06-15", "", "invalid-date" };
        foreach (var input in inputs)
        {
            DateTime? date = ConvertToDate(input);
            if (date.HasValue)
            {
                Console.WriteLine($"変換成功: {date.Value:yyyy-MM-dd}");
            }
            else
            {
                Console.WriteLine($"変換失敗または無効な入力: {input}");
            }
        }
    }
}

変換成功: 2024-06-15
変換失敗または無効な入力:
変換失敗または無効な入力: invalid-date

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string jpDateString = "2024年6月15日";
        string enDateString = "June 15, 2024";
        // 日本語カルチャで解析
        DateTime dateJP = DateTime.ParseExact(jpDateString, "yyyy年M月d日", new CultureInfo("ja-JP"));
        Console.WriteLine($"日本語解析: {dateJP.ToString("D", new CultureInfo("ja-JP"))}");
        // 英語カルチャで解析
        DateTime dateEN = DateTime.ParseExact(enDateString, "MMMM d, yyyy", new CultureInfo("en-US"));
        Console.WriteLine($"英語解析: {dateEN.ToString("D", new CultureInfo("en-US"))}");
    }
}

日本語解析: 2024年6月15日土曜日
英語解析: Saturday, June 15, 2024

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string warekiDate = "令和4年6月15日";
        var culture = new CultureInfo("ja-JP");
        culture.DateTimeFormat.Calendar = new JapaneseCalendar();
        // 和暦の書式で解析
        DateTime date = DateTime.ParseExact(warekiDate, "ggyy年M月d日", culture);
        Console.WriteLine($"和暦解析: {date.ToString("yyyy/MM/dd")}");
        // 和暦で表示
        Console.WriteLine($"和暦表示: {date.ToString("ggyy年M月d日", culture)}");
    }
}

和暦解析: 2022/06/15
和暦表示: 令和04年6月15日

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        DateTime date = new DateTime(2024, 6, 15);
        var gregorian = new CultureInfo("en-US");
        gregorian.DateTimeFormat.Calendar = new GregorianCalendar();
        var japanese = new CultureInfo("ja-JP");
        japanese.DateTimeFormat.Calendar = new JapaneseCalendar();
        Console.WriteLine($"グレゴリオ暦: {date.ToString("yyyy/MM/dd", gregorian)}");
        Console.WriteLine($"和暦: {date.ToString("ggyy年M月d日", japanese)}");
    }
}

グレゴリオ暦: 2024/06/15
和暦: 令和06年6月15日

using System;
class Program
{
    static void Main()
    {
        string isoStringWithZ = "2024-06-15T14:30:00Z";
        string isoStringWithOffset = "2024-06-15T23:30:00+09:00";
        DateTimeOffset dtoZ = DateTimeOffset.Parse(isoStringWithZ);
        DateTimeOffset dtoOffset = DateTimeOffset.Parse(isoStringWithOffset);
        Console.WriteLine($"Z表記のUTC日時: {dtoZ.UtcDateTime}");
        Console.WriteLine($"オフセット表記のUTC日時: {dtoOffset.UtcDateTime}");
    }
}

Z表記のUTC日時: 2024/06/15 14:30:00
オフセット表記のUTC日時: 2024/06/15 14:30:00

using System;
class Program
{
    static void Main()
    {
        // 現在のローカル日時とオフセットを取得
        DateTimeOffset localTime = DateTimeOffset.Now;
        Console.WriteLine($"ローカル日時: {localTime}");
        Console.WriteLine($"UTC日時: {localTime.UtcDateTime}");
        Console.WriteLine($"オフセット: {localTime.Offset}");
        // UTC日時を指定してオフセットを設定
        DateTimeOffset utcTime = new DateTimeOffset(2024, 6, 15, 12, 0, 0, TimeSpan.Zero);
        Console.WriteLine($"UTC日時: {utcTime}");
    }
}

ローカル日時: 2024/06/15 14:30:00 +09:00
UTC日時: 2024/06/15 05:30:00
オフセット: 09:00:00
UTC日時: 2024/06/15 12:00:00 +00:00

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string isoString = "2024-06-15T14:30:00+09:00";
        // Parseでオフセット付き日時を解析
        DateTimeOffset dto = DateTimeOffset.Parse(isoString);
        Console.WriteLine($"Parse結果: {dto}");
        // ParseExactで書式を指定して解析
        string format = "yyyy-MM-ddTHH:mm:sszzz";
        DateTimeOffset dtoExact = DateTimeOffset.ParseExact(isoString, format, CultureInfo.InvariantCulture);
        Console.WriteLine($"ParseExact結果: {dtoExact}");
        // TryParseで安全に解析
        if (DateTimeOffset.TryParse(isoString, out DateTimeOffset dtoTry))
        {
            Console.WriteLine($"TryParse成功: {dtoTry}");
        }
    }
}

Parse結果: 2024/06/15 14:30:00 +09:00
ParseExact結果: 2024/06/15 14:30:00 +09:00
TryParse成功: 2024/06/15 14:30:00 +09:00

using System;
class Program
{
    static void Main()
    {
        string dateString = "2024-06-15T14:30:00";
        ReadOnlySpan<char> span = dateString.AsSpan();
        DateTime date = DateTime.Parse(span);
        Console.WriteLine(date); // 2024/06/15 14:30:00
    }
}

2024/06/15 14:30:00

using System;
using System.Diagnostics;
class Program
{
    static void Main()
    {
        string validDate = "2024-06-15";
        string invalidDate = "invalid";

        var sw = new Stopwatch();

        // 有効な文字列のパース時間計測
        sw.Start();
        for (int i = 0; i < 100000; i++)
        {
            try
            {
                DateTime.Parse(validDate);
            }
            catch (Exception)
            {
                // 例外が発生しないため、ここは通らない
            }
        }
        sw.Stop();
        Console.WriteLine($"有効文字列のParse時間: {sw.ElapsedMilliseconds} ms");

        // 無効な文字列のパース時間計測（例外発生あり）
        sw.Reset();
        sw.Start();
        for (int i = 0; i < 100000; i++)
        {
            try
            {
                DateTime.Parse(invalidDate);
            }
            catch (Exception)
            {
                // 例外キャッチして処理を無視
            }
        }
        sw.Stop();
        Console.WriteLine($"無効文字列のParse時間(例外発生): {sw.ElapsedMilliseconds} ms");
    }
}

有効文字列のParse時間: 141 ms
無効文字列のParse時間(例外発生): 668 ms

using System;
using System.Globalization;
class Program
{
    private static readonly CultureInfo InvariantCulture = CultureInfo.InvariantCulture;
    static void Main()
    {
        string dateString = "2024-06-15";
        // キャッシュしたCultureInfoを使う
        DateTime date = DateTime.Parse(dateString, InvariantCulture);
        Console.WriteLine(date);
    }
}

using System;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Globalization;
public class Event
{
    public string Name { get; set; }
    [JsonConverter(typeof(CustomDateTimeConverter))]
    public DateTime EventDate { get; set; }
}
public class CustomDateTimeConverter : JsonConverter<DateTime>
{
    private const string Format = "yyyy/MM/dd HH:mm:ss";
    public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        string dateString = reader.GetString();
        if (DateTime.TryParseExact(dateString, Format, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime date))
        {
            return date;
        }
        throw new JsonException($"Invalid date format: {dateString}");
    }
    public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
    {
        writer.WriteStringValue(value.ToString(Format));
    }
}
class Program
{
    static void Main()
    {
        string json = @"{ ""Name"": ""Sample Event"", ""EventDate"": ""2024/06/15 14:30:00"" }";
        var options = new JsonSerializerOptions
        {
            PropertyNameCaseInsensitive = true
        };
        Event ev = JsonSerializer.Deserialize<Event>(json, options);
        Console.WriteLine($"イベント名: {ev.Name}");
        Console.WriteLine($"日時: {ev.EventDate}");
    }
}

イベント名: Sample Event
日時: 2024/06/15 14:30:00

using System;
using System.Globalization;
using System.IO;
class Program
{
    static void Main()
    {
        string csvContent = "Id,Name,Date\n1,Item1,2024-06-15\n2,Item2,invalid-date\n3,Item3,06/15/2024";
        using (StringReader reader = new StringReader(csvContent))
        {
            string header = reader.ReadLine(); // ヘッダー読み飛ばし
            string line;
            while ((line = reader.ReadLine()) != null)
            {
                string[] fields = line.Split(',');
                string id = fields[0];
                string name = fields[1];
                string dateStr = fields[2];
                if (DateTime.TryParse(dateStr, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime date))
                {
                    Console.WriteLine($"ID: {id}, 名前: {name}, 日付: {date:yyyy-MM-dd}");
                }
                else
                {
                    Console.WriteLine($"ID: {id}, 名前: {name}, 日付の解析に失敗しました: {dateStr}");
                }
            }
        }
    }
}

ID: 1, 名前: Item1, 日付: 2024-06-15
ID: 2, 名前: Item2, 日付の解析に失敗しました: invalid-date
ID: 3, 名前: Item3, 日付: 2024-06-15

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        Console.WriteLine("日時を入力してください(例: 2024-06-15 14:30):");
        string input = Console.ReadLine();
        if (DateTime.TryParse(input, CultureInfo.CurrentCulture, DateTimeStyles.None, out DateTime date))
        {
            Console.WriteLine($"入力日時: {date}");
        }
        else
        {
            Console.WriteLine("日時の形式が正しくありません。再度入力してください。");
        }
    }
}

日時を入力してください(例: 2024-06-15 14:30):
2024-06-15 14:30
入力日時: 2024/06/15 14:30:00

using System;
class Program
{
    static void Main()
    {
        // 2024年は閏年(4で割り切れる)
        DateTime leapDay = new DateTime(2024, 2, 29);
        Console.WriteLine(leapDay.ToString("yyyy/MM/dd")); // 2024/02/29
        // 1900年は100で割り切れるが400で割り切れないため閏年ではない
        try
        {
            DateTime invalidLeapDay = new DateTime(1900, 2, 29);
        }
        catch (ArgumentOutOfRangeException ex)
        {
            Console.WriteLine("1900年2月29日は存在しません。");
        }
    }
}

2024/02/29
1900年2月29日は存在しません。

using System;
class Program
{
    static void Main()
    {
        TimeZoneInfo est = TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time");
        // 2024年3月10日2時はサマータイム開始で存在しない時間
        DateTime beforeDst = new DateTime(2024, 3, 10, 1, 59, 59);
        DateTime afterDst = new DateTime(2024, 3, 10, 3, 0, 0);
        DateTimeOffset beforeOffset = new DateTimeOffset(beforeDst, est.GetUtcOffset(beforeDst));
        DateTimeOffset afterOffset = new DateTimeOffset(afterDst, est.GetUtcOffset(afterDst));
        Console.WriteLine($"サマータイム開始前: {beforeOffset} (UTCオフセット: {beforeOffset.Offset})");
        Console.WriteLine($"サマータイム開始後: {afterOffset} (UTCオフセット: {afterOffset.Offset})");
    }
}

サマータイム開始前: 2024/03/10 01:59:59 -05:00 (UTCオフセット: -05:00:00)
サマータイム開始後: 2024/03/10 03:00:00 -04:00 (UTCオフセット: -04:00:00)

using System;
class Program
{
    static void Main()
    {
        // 2038年1月19日 03:14:07 UTC(32ビット最大値)
        long maxUnixTime = 2147483647;
        DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
        DateTime maxDate = epoch.AddSeconds(maxUnixTime);
        Console.WriteLine($"32ビットUnixタイムスタンプ最大日時: {maxDate}");
        // これを超えるとオーバーフローの可能性があるため注意
    }
}

32ビットUnixタイムスタンプ最大日時: 2038/01/19 03:14:07

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string dateString = "2024年06月15日";
        string format = "yyyy年MM月dd日";
        DateOnly date = DateOnly.ParseExact(dateString, format, CultureInfo.InvariantCulture);
        Console.WriteLine(date); // 2024-06-15
    }
}

2024-06-15

using System;
class Program
{
    static void Main()
    {
        DateTime now = DateTime.Now;
        // 日付部分のみ取得
        DateOnly datePart = DateOnly.FromDateTime(now);
        // 時間部分のみ取得
        TimeOnly timePart = TimeOnly.FromDateTime(now);
        Console.WriteLine($"元の日時: {now}");
        Console.WriteLine($"日付部分: {datePart}");
        Console.WriteLine($"時間部分: {timePart}");
    }
}

元の日時: 2024/06/15 14:30:45
日付部分: 2024-06-15
時間部分: 14:30:45

DateTime combined = datePart.ToDateTime(timePart);
Console.WriteLine($"結合日時: {combined}");

結合日時: 2024/06/15 14:30:45

DateTime unspecified = new DateTime(2024, 6, 15, 14, 30, 0, DateTimeKind.Unspecified);
DateTime utc = DateTime.SpecifyKind(unspecified, DateTimeKind.Utc);
Console.WriteLine($"Unspecified: {unspecified} Kind={unspecified.Kind}");
Console.WriteLine($"UTCに変換: {utc} Kind={utc.Kind}");

Unspecified: 2024/06/15 14:30:00 Kind=Unspecified
UTCに変換: 2024/06/15 14:30:00 Kind=Utc

using System;
using System.Globalization;
class Program
{
    static void Main()
    {
        string ambiguousDate = "01/02/03";
        DateTime usDate = DateTime.Parse(ambiguousDate, new CultureInfo("en-US"));
        DateTime gbDate = DateTime.Parse(ambiguousDate, new CultureInfo("en-GB"));
        DateTime jpDate = DateTime.Parse(ambiguousDate, new CultureInfo("ja-JP"));
        Console.WriteLine($"en-US解釈: {usDate:yyyy/MM/dd}");
        Console.WriteLine($"en-GB解釈: {gbDate:yyyy/MM/dd}");
        Console.WriteLine($"ja-JP解釈: {jpDate:yyyy/MM/dd}");
    }
}

en-US解釈: 2003/01/02
en-GB解釈: 2003/02/01
ja-JP解釈: 2003/02/01