Elysia Tools

在一个清晰的工作台里浏览工具、案例、可视化和主题指南。

热门分类

专题

语言
ZHESPTRUFRDEEN

Elysia Tools

导航

C#

Windows 日期时间 - C# 示例

Windows平台C#日期时间处理示例,包括DateTime、TimeSpan、TimeZone和日历操作

案例

这个案例集合中的条目

代码csharp简单

获取当前日期和时间

在C#中获取当前日期、时间和进行基本时间计算的各种方法

难度

2/10

预计时间

15 min

标签

csharp, datetime, time, windows

前置条件

Basic C# syntax, Understanding of date/time concepts

csharp
using System;
using System.Globalization;
using System.Linq;

class CurrentTime
{
    // 1. Basic current time operations
    public static void BasicCurrentTime()
    {
        Console.WriteLine("=== Basic Current Time Operations ===");

        // Get current date and time
        DateTime now = DateTime.Now;
        Console.WriteLine($"DateTime.Now: {now}");
        Console.WriteLine($"Date part: {now.Date}");
        Console.WriteLine($"Time of day: {now.TimeOfDay}");

        // Get UTC time
        DateTime utcNow = DateTime.UtcNow;
        Console.WriteLine($"\nDateTime.UtcNow: {utcNow}");

        // Get current date only
        DateTime today = DateTime.Today;
        Console.WriteLine($"DateTime.Today: {today}");

        // Get ticks (100-nanosecond intervals since 1/1/0001)
        long ticks = DateTime.Now.Ticks;
        Console.WriteLine($"\nTicks: {ticks:N0}");
        Console.WriteLine($"Ticks since 1/1/0001: {TimeSpan.FromTicks(ticks).TotalDays:F0} days");
    }

    // 2. DateTime components
    public static void DateTimeComponents()
    {
        Console.WriteLine("\n=== DateTime Components ===");

        DateTime now = DateTime.Now;

        Console.WriteLine($"Year: {now.Year}");
        Console.WriteLine($"Month: {now.Month} ({now.ToString("MMMM")})");
        Console.WriteLine($"Day: {now.Day}");
        Console.WriteLine($"Hour: {now.Hour}");
        Console.WriteLine($"Minute: {now.Minute}");
        Console.WriteLine($"Second: {now.Second}");
        Console.WriteLine($"Millisecond: {now.Millisecond}");

        // Day of week and day of year
        Console.WriteLine($"\nDay of Week: {now.DayOfWeek} ({(int)now.DayOfWeek})");
        Console.WriteLine($"Day of Year: {now.DayOfYear}");

        // Time of day
        Console.WriteLine($"\nTime of Day: {now.TimeOfDay}");
        Console.WriteLine($"Total hours since midnight: {now.TimeOfDay.TotalHours:F2}");
        Console.WriteLine($"Total minutes since midnight: {now.TimeOfDay.TotalMinutes:F0}");
    }

    // 3. DateTime creation
    public static void DateTimeCreation()
    {
        Console.WriteLine("\n=== DateTime Creation ===");

        // Create specific DateTime
        DateTime specificDate = new DateTime(2024, 12, 25);
        Console.WriteLine($"Specific date: {specificDate:yyyy-MM-dd}");

        // Create DateTime with time
        DateTime specificDateTime = new DateTime(2024, 12, 25, 14, 30, 45);
        Console.WriteLine($"Specific datetime: {specificDateTime:yyyy-MM-dd HH:mm:ss}");

        // Create with milliseconds
        DateTime withMilliseconds = new DateTime(2024, 12, 25, 14, 30, 45, 123);
        Console.WriteLine($"With milliseconds: {withMilliseconds:yyyy-MM-dd HH:mm:ss.fff}");

        // Create from string
        DateTime fromString = DateTime.Parse("2024-12-25 14:30:45");
        Console.WriteLine($"From string: {fromString:yyyy-MM-dd HH:mm:ss}");

        // Create with specific format
        DateTime withFormat = DateTime.ParseExact("25/12/2024", "dd/MM/yyyy", CultureInfo.InvariantCulture);
        Console.WriteLine($"With format: {withFormat:yyyy-MM-dd}");

        // Create from ticks
        long customTicks = new DateTime(2024, 1, 1).Ticks;
        DateTime fromTicks = new DateTime(customTicks);
        Console.WriteLine($"From ticks: {fromTicks:yyyy-MM-dd}");
    }

    // 4. Date and time arithmetic
    public static void DateTimeArithmetic()
    {
        Console.WriteLine("\n=== Date and Time Arithmetic ===");

        DateTime baseDate = new DateTime(2024, 1, 1, 12, 0, 0);
        Console.WriteLine($"Base date: {baseDate:yyyy-MM-dd HH:mm:ss}");

        // Adding time
        DateTime plusDays = baseDate.AddDays(10);
        DateTime plusHours = baseDate.AddHours(5);
        DateTime plusMinutes = baseDate.AddMinutes(30);
        DateTime plusSeconds = baseDate.AddSeconds(45);
        DateTime plusMonths = baseDate.AddMonths(2);
        DateTime plusYears = baseDate.AddYears(1);

        Console.WriteLine($"\nAdd 10 days: {plusDays:yyyy-MM-dd HH:mm:ss}");
        Console.WriteLine($"Add 5 hours: {plusHours:yyyy-MM-dd HH:mm:ss}");
        Console.WriteLine($"Add 30 minutes: {plusMinutes:yyyy-MM-dd HH:mm:ss}");
        Console.WriteLine($"Add 45 seconds: {plusSeconds:yyyy-MM-dd HH:mm:ss}");
        Console.WriteLine($"Add 2 months: {plusMonths:yyyy-MM-dd HH:mm:ss}");
        Console.WriteLine($"Add 1 year: {plusYears:yyyy-MM-dd HH:mm:ss}");

        // Subtracting time
        DateTime subtracted = baseDate.Subtract(TimeSpan.FromDays(7));
        Console.WriteLine($"\nSubtract 7 days: {subtracted:yyyy-MM-dd HH:mm:ss}");

        // Calculate difference
        DateTime otherDate = new DateTime(2024, 1, 15, 18, 30, 0);
        TimeSpan difference = otherDate - baseDate;
        Console.WriteLine($"\nDifference between {otherDate:yyyy-MM-dd HH:mm:ss} and {baseDate:yyyy-MM-dd HH:mm:ss}:");
        Console.WriteLine($"Total days: {difference.TotalDays}");
        Console.WriteLine($"Total hours: {difference.TotalHours}");
        Console.WriteLine($"Total minutes: {difference.TotalMinutes}");
    }

    // 5. TimeSpan operations
    public static void TimeSpanOperations()
    {
        Console.WriteLine("\n=== TimeSpan Operations ===");

        // Create TimeSpan
        TimeSpan ts1 = new TimeSpan(1, 30, 45);  // 1 hour, 30 minutes, 45 seconds
        TimeSpan ts2 = TimeSpan.FromDays(2.5);     // 2.5 days
        TimeSpan ts3 = TimeSpan.Parse("01:45:30"); // Parse from string

        Console.WriteLine($"TimeSpan 1: {ts1}");
        Console.WriteLine($"TimeSpan 2: {ts2}");
        Console.WriteLine($"TimeSpan 3: {ts3}");

        // TimeSpan components
        Console.WriteLine("\nTimeSpan 1 components:");
        Console.WriteLine($"Days: {ts1.Days}");
        Console.WriteLine($"Hours: {ts1.Hours}");
        Console.WriteLine($"Minutes: {ts1.Minutes}");
        Console.WriteLine($"Seconds: {ts1.Seconds}");
        Console.WriteLine($"TotalDays: {ts1.TotalDays:F2}");
        Console.WriteLine($"TotalHours: {ts1.TotalHours:F2}");
        Console.WriteLine($"TotalMinutes: {ts1.TotalMinutes:F2}");
        Console.WriteLine($"TotalSeconds: {ts1.TotalSeconds:F0}");

        // TimeSpan arithmetic
        TimeSpan sum = ts1 + ts3;
        TimeSpan difference = ts2 - ts1;
        TimeSpan doubled = ts1 * 2;
        TimeSpan halved = ts1 / 2;

        Console.WriteLine($"\nTimeSpan arithmetic:");
        Console.WriteLine($"ts1 + ts3 = {sum}");
        Console.WriteLine($"ts2 - ts1 = {difference}");
        Console.WriteLine($"ts1 * 2 = {doubled}");
        Console.WriteLine($"ts1 / 2 = {halved}");

        // TimeSpan formatting
        Console.WriteLine($"\nFormatted TimeSpan:");
        Console.WriteLine($"General format: {ts1}");
        Console.WriteLine(@"hh:mm:ss: {ts1:hh\:mm\:ss}");
        Console.WriteLine(@"g format: {ts1:g}");
        Console.WriteLine(@"G format: {ts1:G}");
    }

    // 6. Date comparison
    public static void DateComparison()
    {
        Console.WriteLine("\n=== Date Comparison ===");

        DateTime date1 = new DateTime(2024, 12, 25);
        DateTime date2 = new DateTime(2024, 12, 25);
        DateTime date3 = new DateTime(2024, 12, 26);

        Console.WriteLine($"date1: {date1:yyyy-MM-dd}");
        Console.WriteLine($"date2: {date2:yyyy-MM-dd}");
        Console.WriteLine($"date3: {date3:yyyy-MM-dd}");

        // Equality comparison
        Console.WriteLine($"\nEquality:");
        Console.WriteLine($"date1 == date2: {date1 == date2}");
        Console.WriteLine($"date1 == date3: {date1 == date3}");
        Console.WriteLine($"date1.Equals(date2): {date1.Equals(date2)}");

        // Relational comparison
        Console.WriteLine("\nRelational:");
        Console.WriteLine($"date1 < date3: {date1 < date3}");
        Console.WriteLine($"date1 > date3: {date1 > date3}");
        Console.WriteLine($"date1 <= date2: {date1 <= date2}");
        Console.WriteLine($"date1 >= date2: {date1 >= date2}");

        // Compare method
        Console.WriteLine("\nCompare method:");
        Console.WriteLine($"date1.CompareTo(date2): {date1.CompareTo(date2)}");  // 0 = equal
        Console.WriteLine($"date1.CompareTo(date3): {date1.CompareTo(date3)}");  // -1 = less than
        Console.WriteLine($"date3.CompareTo(date1): {date3.CompareTo(date1)}");  // 1 = greater than

        // Static comparison methods
        Console.WriteLine("\nStatic comparison:");
        Console.WriteLine($"DateTime.Equals(date1, date2): {DateTime.Equals(date1, date2)}");
        Console.WriteLine($"DateTime.Compare(date1, date2): {DateTime.Compare(date1, date2)}");
        Console.WriteLine($"DateTime.Compare(date1, date3): {DateTime.Compare(date1, date3)}");
    }

    // 7. Maximum and minimum dates
    public static void MinMaxDates()
    {
        Console.WriteLine("\n=== Minimum and Maximum Dates ===");

        Console.WriteLine($"DateTime.MinValue: {DateTime.MinValue}");
        Console.WriteLine($"DateTime.MaxValue: {DateTime.MaxValue}");
        Console.WriteLine($"TimeSpan.MinValue: {TimeSpan.MinValue}");
        Console.WriteLine($"TimeSpan.MaxValue: {TimeSpan.MaxValue}");

        // Age calculation
        DateTime birthDate = new DateTime(1990, 5, 15);
        DateTime today = DateTime.Today;
        int age = today.Year - birthDate.Year;
        if (birthDate > today.AddYears(-age))
        {
            age--;
        }

        Console.WriteLine($"\nAge calculation:");
        Console.WriteLine($"Birth date: {birthDate:yyyy-MM-dd}");
        Console.WriteLine($"Today: {today:yyyy-MM-dd}");
        Console.WriteLine($"Age: {age} years");

        // Days until next birthday
        DateTime nextBirthday = new DateTime(today.Year, birthDate.Month, birthDate.Day);
        if (nextBirthday < today)
        {
            nextBirthday = nextBirthday.AddYears(1);
        }

        TimeSpan untilBirthday = nextBirthday - today;
        Console.WriteLine($"Days until next birthday: {untilBirthday.Days}");
    }

    // 8. Date validation and parsing
    public static void DateValidationAndParsing()
    {
        Console.WriteLine("\n=== Date Validation and Parsing ===");

        string[] dateStrings = {
            "2024-12-25",
            "25/12/2024",
            "December 25, 2024",
            "2024-12-25 14:30:45",
            "invalid date",
            "31/02/2024",  // Invalid February date
            "2024-13-01"    // Invalid month
        };

        Console.WriteLine("Date parsing attempts:");
        foreach (string dateStr in dateStrings)
        {
            Console.WriteLine($"\nTrying to parse: '{dateStr}'");

            // TryParse
            if (DateTime.TryParse(dateStr, out DateTime parsedDate))
            {
                Console.WriteLine($"  TryParse success: {parsedDate:yyyy-MM-dd HH:mm:ss}");
            }
            else
            {
                Console.WriteLine($"  TryParse failed");
            }

            // TryParse with specific culture
            if (DateTime.TryParse(dateStr, CultureInfo.GetCultureInfo("en-GB"), DateTimeStyles.None, out DateTime ukDate))
            {
                Console.WriteLine($"  UK format success: {ukDate:yyyy-MM-dd HH:mm:ss}");
            }

            // TryParseExact
            string[] formats = { "yyyy-MM-dd", "dd/MM/yyyy", "MMMM dd, yyyy", "yyyy-MM-dd HH:mm:ss" };
            if (DateTime.TryParseExact(dateStr, formats, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime exactDate))
            {
                Console.WriteLine($"  TryParseExact success: {exactDate:yyyy-MM-dd HH:mm:ss}");
            }
        }
    }

    // 9. Performance considerations
    public static void PerformanceConsiderations()
    {
        Console.WriteLine("\n=== Performance Considerations ===");

        const int iterations = 100000;
        var stopwatch = System.Diagnostics.Stopwatch.StartNew();

        // Test DateTime.Now vs DateTime.UtcNow
        stopwatch.Restart();
        for (int i = 0; i < iterations; i++)
        {
            DateTime local = DateTime.Now;
        }
        stopwatch.Stop();
        Console.WriteLine($"DateTime.Now x {iterations:N0}: {stopwatch.ElapsedMilliseconds}ms");

        stopwatch.Restart();
        for (int i = 0; i < iterations; i++)
        {
            DateTime utc = DateTime.UtcNow;
        }
        stopwatch.Stop();
        Console.WriteLine($"DateTime.UtcNow x {iterations:N0}: {stopwatch.ElapsedMilliseconds}ms");

        // Test DateTime creation
        stopwatch.Restart();
        for (int i = 0; i < iterations; i++)
        {
            DateTime created = new DateTime(2024, 1, 1, 12, 0, 0);
        }
        stopwatch.Stop();
        Console.WriteLine($"DateTime constructor x {iterations:N0}: {stopwatch.ElapsedMilliseconds}ms");

        // Test date comparison
        DateTime date1 = new DateTime(2024, 1, 1);
        DateTime date2 = new DateTime(2024, 1, 2);

        stopwatch.Restart();
        for (int i = 0; i < iterations; i++)
        {
            bool isEqual = date1 == date2;
            bool isLess = date1 < date2;
            int compare = date1.CompareTo(date2);
        }
        stopwatch.Stop();
        Console.WriteLine($"Date comparisons x {iterations:N0}: {stopwatch.ElapsedMilliseconds}ms");
    }

    // 10. Real-world examples
    public static void RealWorldExamples()
    {
        Console.WriteLine("\n=== Real-world Examples ===");

        // Example 1: Working days calculation
        DateTime startDate = new DateTime(2024, 1, 1);
        DateTime endDate = new DateTime(2024, 1, 31);
        int workingDays = CalculateWorkingDays(startDate, endDate);

        Console.WriteLine($"Working days between {startDate:yyyy-MM-dd} and {endDate:yyyy-MM-dd}: {workingDays}");

        // Example 2: Find next occurrence of day of week
        DateTime nextMonday = FindNextDayOfWeek(DateTime.Today, DayOfWeek.Monday);
        Console.WriteLine($"Next Monday: {nextMonday:yyyy-MM-dd}");

        // Example 3: First and last day of month
        DateTime today = DateTime.Today;
        DateTime firstDayOfMonth = new DateTime(today.Year, today.Month, 1);
        DateTime lastDayOfMonth = firstDayOfMonth.AddMonths(1).AddDays(-1);

        Console.WriteLine($"\nToday: {today:yyyy-MM-dd}");
        Console.WriteLine($"First day of month: {firstDayOfMonth:yyyy-MM-dd}");
        Console.WriteLine($"Last day of month: {lastDayOfMonth:yyyy-MM-dd}");

        // Example 4: Quarter information
        int quarter = (today.Month - 1) / 3 + 1;
        DateTime quarterStart = new DateTime(today.Year, (quarter - 1) * 3 + 1, 1);
        DateTime quarterEnd = quarterStart.AddMonths(3).AddDays(-1);

        Console.WriteLine($"\nCurrent quarter: Q{quarter}");
        Console.WriteLine($"Quarter start: {quarterStart:yyyy-MM-dd}");
        Console.WriteLine($"Quarter end: {quarterEnd:yyyy-MM-dd}");

        // Example 5: Time until end of day/year
        DateTime endOfDay = today.AddDays(1).AddTicks(-1);
        DateTime endOfYear = new DateTime(today.Year, 12, 31, 23, 59, 59);

        TimeSpan untilEndOfDay = endOfDay - DateTime.Now;
        TimeSpan untilEndOfYear = endOfYear - DateTime.Now;

        Console.WriteLine($"\nTime until end of day: {untilEndOfDay.Hours}h {untilEndOfDay.Minutes}m");
        Console.WriteLine($"Time until end of year: {untilEndOfYear.Days} days {untilEndOfYear.Hours}h");
    }

    // Helper methods for real-world examples
    static int CalculateWorkingDays(DateTime start, DateTime end)
    {
        int days = 0;
        DateTime current = start;

        while (current <= end)
        {
            if (current.DayOfWeek != DayOfWeek.Saturday && current.DayOfWeek != DayOfWeek.Sunday)
            {
                days++;
            }
            current = current.AddDays(1);
        }

        return days;
    }

    static DateTime FindNextDayOfWeek(DateTime date, DayOfWeek dayOfWeek)
    {
        int daysToAdd = ((int)dayOfWeek - (int)date.DayOfWeek + 7) % 7;
        return date.AddDays(daysToAdd == 0 ? 7 : daysToAdd);
    }

    static void Main(string[] args)
    {
        Console.WriteLine("=== C# Current Time Demo ===\n");

        try
        {
            BasicCurrentTime();
            DateTimeComponents();
            DateTimeCreation();
            DateTimeArithmetic();
            TimeSpanOperations();
            DateComparison();
            MinMaxDates();
            DateValidationAndParsing();
            PerformanceConsiderations();
            RealWorldExamples();

            Console.WriteLine("\nAll current time examples completed successfully!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error in current time demo: {ex.Message}");
        }
    }
}
代码csharp中等

日期和时间格式化

全面的日期和时间格式化选项,包括特定文化格式、自定义模式和字符串解析

难度

5/10

预计时间

25 min

标签

csharp, datetime, formatting, culture, localization, windows

前置条件

C# DateTime basics, CultureInfo, String formatting

csharp
using System;
using System.Globalization;

class TimeFormatting
{
    // 1. Standard format strings
    public static void StandardFormatStrings()
    {
        Console.WriteLine("=== Standard Format Strings ===");

        DateTime now = DateTime.Now;

        Console.WriteLine($"Current DateTime: {now}");
        Console.WriteLine();

        // Date formats
        Console.WriteLine("Date Formats:");
        Console.WriteLine($"d (short date): {now:d}");
        Console.WriteLine($"D (long date): {now:D}");
        Console.WriteLine($"f (full date short time): {now:f}");
        Console.WriteLine($"F (full date long time): {now:F}");
        Console.WriteLine($"g (general date short time): {now:g}");
        Console.WriteLine($"G (general date long time): {now:G}");
        Console.WriteLine($"M/m (month day): {now:M}");
        Console.WriteLine($"Y/y (year month): {now:Y}");
        Console.WriteLine();

        // Time formats
        Console.WriteLine("Time Formats:");
        Console.WriteLine($"t (short time): {now:t}");
        Console.WriteLine($"T (long time): {now:T}");
        Console.WriteLine();

        // Combined formats
        Console.WriteLine("Combined Formats:");
        Console.WriteLine($"o (round-trip): {now:o}");
        Console.WriteLine($"s (sortable): {now:s}");
        Console.WriteLine($"u (universal sortable): {now:u}");
        Console.WriteLine($"U (universal full): {now:U}");
    }

    // 2. Custom format strings
    public static void CustomFormatStrings()
    {
        Console.WriteLine("\n=== Custom Format Strings ===");

        DateTime now = DateTime.Now;

        Console.WriteLine($"Current DateTime: {now}");
        Console.WriteLine();

        // Year formats
        Console.WriteLine("Year Formats:");
        Console.WriteLine($"yyyy (4-digit year): {now:yyyy}");
        Console.WriteLine($"yy (2-digit year): {now:yy}");
        Console.WriteLine();

        // Month formats
        Console.WriteLine("Month Formats:");
        Console.WriteLine($"MM (2-digit month): {now:MM}");
        Console.WriteLine($"M (1-2 digit month): {now:M}");
        Console.WriteLine($"MMMM (full month name): {now:MMMM}");
        Console.WriteLine($"MMM (abbreviated month): {now:MMM}");
        Console.WriteLine();

        // Day formats
        Console.WriteLine("Day Formats:");
        Console.WriteLine($"dd (2-digit day): {now:dd}");
        Console.WriteLine($"d (1-2 digit day): {now:d}");
        Console.WriteLine($"dddd (full day name): {now:dddd}");
        Console.WriteLine($"ddd (abbreviated day): {now:ddd}");
        Console.WriteLine();

        // Hour formats
        Console.WriteLine("Hour Formats:");
        Console.WriteLine($"HH (24-hour 2-digit): {now:HH}");
        Console.WriteLine($"H (24-hour 1-2 digit): {now:H}");
        Console.WriteLine($"hh (12-hour 2-digit): {now:hh}");
        Console.WriteLine($"h (12-hour 1-2 digit): {now:h}");
        Console.WriteLine();

        // Minute and second formats
        Console.WriteLine("Minute/Second Formats:");
        Console.WriteLine($"mm (2-digit minute): {now:mm}");
        Console.WriteLine($"m (1-2 digit minute): {now:m}");
        Console.WriteLine($"ss (2-digit second): {now:ss}");
        Console.WriteLine($"s (1-2 digit second): {now:s}");
        Console.WriteLine();

        // AM/PM designator
        Console.WriteLine($"tt (AM/PM): {now:tt}");
        Console.WriteLine($"t (first letter AM/PM): {now:t}");
    }

    // 3. Complex custom formats
    public static void ComplexCustomFormats()
    {
        Console.WriteLine("\n=== Complex Custom Formats ===");

        DateTime now = DateTime.Now;

        // Common business formats
        Console.WriteLine("Common Business Formats:");
        Console.WriteLine($"ISO 8601: {now:yyyy-MM-ddTHH:mm:ss}");
        Console.WriteLine($"Readable: {now:dddd, MMMM dd, yyyy HH:mm:ss}");
        Console.WriteLine($"Filename format: {now:yyyyMMdd_HHmmss}");
        Console.WriteLine($"Log format: {now:yyyy-MM-dd HH:mm:ss.fff}");
        Console.WriteLine($"US format: {now:MM/dd/yyyy hh:mm:ss tt}");
        Console.WriteLine($"European format: {now:dd.MM.yyyy HH:mm:ss}");
        Console.WriteLine($"Sortable: {now:yyyy-MM-dd HH:mm:ss}");

        // Custom examples
        Console.WriteLine("\nCustom Examples:");
        Console.WriteLine($"With timezone: {now:yyyy-MM-dd HH:mm:ss zzz}");
        Console.WriteLine($"Quarter format: Q{((now.Month - 1) / 3) + 1} {now:yyyy}");
        Console.WriteLine($"Week number: Week {CultureInfo.InvariantCulture.Calendar.GetWeekOfYear(now, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday)}, {now:yyyy}");

        // Custom formatting with literals
        Console.WriteLine("\nFormatting with Literals:");
        Console.WriteLine($"With quotes: {now:"Year" yyyy "Month" MM}");
        Console.WriteLine($"With escapes: {now:yyyy\\MM\\dd}");
    }

    // 4. Culture-specific formatting
    public static void CultureSpecificFormatting()
    {
        Console.WriteLine("\n=== Culture-Specific Formatting ===");

        DateTime now = DateTime.Now;

        // Different cultures
        CultureInfo[] cultures = {
            CultureInfo.GetCultureInfo("en-US"),  // English (United States)
            CultureInfo.GetCultureInfo("en-GB"),  // English (United Kingdom)
            CultureInfo.GetCultureInfo("fr-FR"),  // French (France)
            CultureInfo.GetCultureInfo("de-DE"),  // German (Germany)
            CultureInfo.GetCultureInfo("ja-JP"),  // Japanese (Japan)
            CultureInfo.GetCultureInfo("ar-SA"),  // Arabic (Saudi Arabia)
            CultureInfo.GetCultureInfo("zh-CN"),  // Chinese (China)
            CultureInfo.GetCultureInfo("es-ES")   // Spanish (Spain)
        };

        Console.WriteLine($"Current DateTime: {now}");
        Console.WriteLine();

        Console.WriteLine("Date formats by culture:");
        foreach (var culture in cultures)
        {
            Console.WriteLine($"{culture.Name,-8}: {now.ToString("d", culture)} | {now.ToString("D", culture)}");
        }

        Console.WriteLine("\nTime formats by culture:");
        foreach (var culture in cultures)
        {
            Console.WriteLine($"{culture.Name,-8}: {now.ToString("t", culture)} | {now.ToString("T", culture)}");
        }

        Console.WriteLine("\nFull date/time formats by culture:");
        foreach (var culture in cultures)
        {
            Console.WriteLine($"{culture.Name,-8}: {now.ToString("F", culture)}");
        }
    }

    // 5. TimeSpan formatting
    public static void TimeSpanFormatting()
    {
        Console.WriteLine("\n=== TimeSpan Formatting ===");

        TimeSpan[] timespans = {
            TimeSpan.FromDays(1.5),
            TimeSpan.FromHours(12.75),
            TimeSpan.FromMinutes(123.45),
            TimeSpan.FromSeconds(3661),
            TimeSpan.Parse("01:23:45.678")
        };

        Console.WriteLine("TimeSpan Formatting:");
        foreach (var ts in timespans)
        {
            Console.WriteLine($"\nTimeSpan: {ts}");
            Console.WriteLine(@"c format: {ts:c}");
            Console.WriteLine(@"g format: {ts:g}");
            Console.WriteLine(@"G format: {ts:G}");
            Console.WriteLine(@"Custom (hh\:mm\:ss): {ts:hh\:mm\:ss}");
            Console.WriteLine(@"Custom (d\.hh\:mm\:ss): {ts:d\.hh\:mm\:ss}");
            Console.WriteLine(@"Total hours: {ts.TotalHours:F2}");
            Console.WriteLine(@"Total minutes: {ts.TotalMinutes:F0}");
            Console.WriteLine(@"Total seconds: {ts.TotalSeconds:F0}");
        }

        // Duration formatting
        Console.WriteLine("\nDuration Formatting Examples:");
        TimeSpan duration = TimeSpan.Parse("02:15:30.123");
        Console.WriteLine($"Duration: {duration}");
        Console.WriteLine($"Hours and minutes: {duration:hh\:mm}");
        Console.WriteLine(@"With seconds: {duration:hh\:mm\:ss}");
        Console.WriteLine(@"With milliseconds: {duration:hh\:mm\:ss\.fff}");
        Console.WriteLine($"Friendly format: {FormatFriendlyDuration(duration)}");
    }

    // 6. String parsing with formats
    public static void StringParsingWithFormats()
    {
        Console.WriteLine("\n=== String Parsing with Formats ===");

        string[] dateStrings = {
            "2024-12-25",
            "25/12/2024",
            "December 25, 2024",
            "2024-12-25 14:30:45",
            "2:30 PM",
            "2024-12-25T14:30:45.123Z",
            "25 Dec 2024 2:30:45 PM"
        };

        string[] formats = {
            "yyyy-MM-dd",
            "dd/MM/yyyy",
            "MMMM dd, yyyy",
            "yyyy-MM-dd HH:mm:ss",
            "h:mm tt",
            "yyyy-MM-ddTHH:mm:ss.fffZ",
            "dd MMM yyyy h:mm:ss tt"
        };

        Console.WriteLine("String Parsing Examples:");
        foreach (string dateStr in dateStrings)
        {
            Console.WriteLine($"\nParsing: '{dateStr}'");

            // TryParseExact with all formats
            if (DateTime.TryParseExact(dateStr, formats, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime parsedDate))
            {
                Console.WriteLine($"  Successfully parsed: {parsedDate:yyyy-MM-dd HH:mm:ss}");
            }
            else
            {
                Console.WriteLine("  Failed to parse with TryParseExact");

                // Try regular TryParse
                if (DateTime.TryParse(dateStr, out DateTime generalParsed))
                {
                    Console.WriteLine($"  General parse success: {generalParsed:yyyy-MM-dd HH:mm:ss}");
                }
                else
                {
                    Console.WriteLine("  General parse failed");
                }
            }
        }
    }

    // 7. Advanced formatting scenarios
    public static void AdvancedFormattingScenarios()
    {
        Console.WriteLine("\n=== Advanced Formatting Scenarios ===");

        DateTime now = DateTime.Now;

        // Scenario 1: Relative time formatting
        Console.WriteLine("Relative Time Formatting:");
        Console.WriteLine($"Time ago: {FormatRelativeTime(now.AddHours(-2))}");
        Console.WriteLine($"Time ago: {FormatRelativeTime(now.AddDays(-3))}");
        Console.WriteLine($"Time until: {FormatRelativeTime(now.AddHours(5))}");
        Console.WriteLine($"Time until: {FormatRelativeTime(now.AddDays(10))}");

        // Scenario 2: Fuzzy time formatting
        Console.WriteLine("\nFuzzy Time Formatting:");
        DateTime testTime = new DateTime(now.Year, now.Month, now.Day, 14, 27, 0);
        Console.WriteLine($"Actual time: {testTime:HH:mm}");
        Console.WriteLine($"Fuzzy time: {FormatFuzzyTime(testTime)}");

        testTime = new DateTime(now.Year, now.Month, now.Day, 9, 33, 0);
        Console.WriteLine($"Actual time: {testTime:HH:mm}");
        Console.WriteLine($"Fuzzy time: {FormatFuzzyTime(testTime)}");

        // Scenario 3: Age calculation with units
        DateTime birthDate = new DateTime(1990, 5, 15);
        Console.WriteLine($"\nAge calculation:");
        Console.WriteLine($"Birth date: {birthDate:yyyy-MM-dd}");
        Console.WriteLine($"Current age: {FormatAge(birthDate)}");

        // Scenario 4: Business date formatting
        Console.WriteLine("\nBusiness Date Formatting:");
        DateTime businessDate = new DateTime(2024, 12, 25);
        Console.WriteLine($"Date: {businessDate:yyyy-MM-dd}");
        Console.WriteLine($"Business format: {FormatBusinessDate(businessDate)}");
        Console.WriteLine($"Quarter: Q{((businessDate.Month - 1) / 3) + 1} {businessDate:yyyy}");
        Console.WriteLine($"Week: Week {CultureInfo.InvariantCulture.Calendar.GetWeekOfYear(businessDate, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday)}");
    }

    // 8. DateTime serialization
    public static void DateTimeSerialization()
    {
        Console.WriteLine("\n=== DateTime Serialization ===");

        DateTime now = DateTime.Now;

        // ISO 8601 formats
        string isoLocal = now.ToString("yyyy-MM-ddTHH:mm:ss");
        string isoWithOffset = now.ToString("yyyy-MM-ddTHH:mm:sszzz");
        string isoUtc = now.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ");

        Console.WriteLine("ISO 8601 Formats:");
        Console.WriteLine($"Local: {isoLocal}");
        Console.WriteLine($"With offset: {isoWithOffset}");
        Console.WriteLine($"UTC: {isoUtc}");

        // Round-trip format
        string roundTrip = now.ToString("o");
        Console.WriteLine($"\nRound-trip format: {roundTrip}");

        // Parse back
        DateTime parsedFromRoundTrip = DateTime.Parse(roundTrip, null, DateTimeStyles.RoundtripKind);
        Console.WriteLine($"Parsed back: {parsedFromRoundTrip:yyyy-MM-dd HH:mm:ss.fff}");
        Console.WriteLine($"Equals original: {now == parsedFromRoundTrip}");

        // JSON friendly formats
        string jsonFormat = now.ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
        Console.WriteLine($"\nJSON friendly: {jsonFormat}");
    }

    // 9. Performance considerations
    public static void PerformanceConsiderations()
    {
        Console.WriteLine("\n=== Performance Considerations ===");

        const int iterations = 100000;
        DateTime testDate = DateTime.Now;

        // Test different formatting methods
        var stopwatch = System.Diagnostics.Stopwatch.StartNew();

        // ToString with format
        stopwatch.Restart();
        for (int i = 0; i < iterations; i++)
        {
            string formatted = testDate.ToString("yyyy-MM-dd HH:mm:ss");
        }
        stopwatch.Stop();
        Console.WriteLine($"ToString with format x {iterations:N0}: {stopwatch.ElapsedMilliseconds}ms");

        // Composite formatting
        stopwatch.Restart();
        for (int i = 0; i < iterations; i++)
        {
            string formatted = string.Format("{0:yyyy-MM-dd HH:mm:ss}", testDate);
        }
        stopwatch.Stop();
        Console.WriteLine($"String.Format x {iterations:N0}: {stopwatch.ElapsedMilliseconds}ms");

        // String interpolation
        stopwatch.Restart();
        for (int i = 0; i < iterations; i++)
        {
            string formatted = $"{testDate:yyyy-MM-dd HH:mm:ss}";
        }
        stopwatch.Stop();
        Console.WriteLine($"String interpolation x {iterations:N0}: {stopwatch.ElapsedMilliseconds}ms");

        // StringBuilder
        stopwatch.Restart();
        for (int i = 0; i < iterations; i++)
        {
            var sb = new System.Text.StringBuilder();
            sb.Append(testDate.ToString("yyyy-"));
            sb.Append(testDate.ToString("MM-"));
            sb.Append(testDate.ToString("dd "));
            sb.Append(testDate.ToString("HH:"));
            sb.Append(testDate.ToString("mm:"));
            sb.Append(testDate.ToString("ss"));
            string formatted = sb.ToString();
        }
        stopwatch.Stop();
        Console.WriteLine($"StringBuilder x {iterations:N0}: {stopwatch.ElapsedMilliseconds}ms");
    }

    // Helper methods for advanced scenarios
    static string FormatFriendlyDuration(TimeSpan ts)
    {
        if (ts.TotalDays >= 1)
        {
            int days = (int)ts.TotalDays;
            int hours = ts.Hours;
            return $"{days}d {hours}h";
        }
        else if (ts.TotalHours >= 1)
        {
            int hours = (int)ts.TotalHours;
            int minutes = ts.Minutes;
            return $"{hours}h {minutes}m";
        }
        else if (ts.TotalMinutes >= 1)
        {
            int minutes = (int)ts.TotalMinutes;
            return $"{minutes}m";
        }
        else
        {
            return $"{ts.Seconds}s";
        }
    }

    static string FormatRelativeTime(DateTime dateTime)
    {
        TimeSpan difference = dateTime - DateTime.Now;

        if (Math.Abs(difference.TotalSeconds) < 60)
        {
            return difference.TotalSeconds > 0 ? "in less than a minute" : "just now";
        }
        else if (Math.Abs(difference.TotalMinutes) < 60)
        {
            int minutes = (int)Math.Abs(difference.TotalMinutes);
            return difference.TotalMinutes > 0 ? $"in {minutes} minute{(minutes > 1 ? "s" : "")}" : $"{minutes} minute{(minutes > 1 ? "s" : "")} ago";
        }
        else if (Math.Abs(difference.TotalHours) < 24)
        {
            int hours = (int)Math.Abs(difference.TotalHours);
            return difference.TotalHours > 0 ? $"in {hours} hour{(hours > 1 ? "s" : "")}" : $"{hours} hour{(hours > 1 ? "s" : "")} ago";
        }
        else
        {
            int days = (int)Math.Abs(difference.TotalDays);
            return difference.TotalDays > 0 ? $"in {days} day{(days > 1 ? "s" : "")}" : $"{days} day{(days > 1 ? "s" : "")} ago";
        }
    }

    static string FormatFuzzyTime(DateTime time)
    {
        int hour = time.Hour;
        int minute = time.Minute;

        if (minute < 8)
            return $"{hour} o'clock";
        else if (minute < 23)
            return $"quarter past {hour}";
        else if (minute < 38)
            return $"half past {hour}";
        else if (minute < 53)
            return $"quarter to {(hour % 12) + 1}";
        else
            return $"{(hour % 12) + 1} o'clock";
    }

    static string FormatAge(DateTime birthDate)
    {
        DateTime today = DateTime.Today;
        int years = today.Year - birthDate.Year;
        int months = today.Month - birthDate.Month;
        int days = today.Day - birthDate.Day;

        if (days < 0)
        {
            months--;
            days += DateTime.DaysInMonth(today.Year, today.Month == 1 ? 12 : today.Month - 1);
        }

        if (months < 0)
        {
            years--;
            months += 12;
        }

        if (years > 0)
            return $"{years} year{(years > 1 ? "s" : "")}";
        else if (months > 0)
            return $"{months} month{(months > 1 ? "s" : "")}";
        else
            return $"{days} day{(days > 1 ? "s" : "")}";
    }

    static string FormatBusinessDate(DateTime date)
    {
        string dayName = date.ToString("ddd, MMM dd");
        if (date == DateTime.Today)
            return $"{dayName} (Today)";
        else if (date == DateTime.Today.AddDays(1))
            return $"{dayName} (Tomorrow)";
        else if (date == DateTime.Today.AddDays(-1))
            return $"{dayName} (Yesterday)";
        else
            return dayName;
    }

    static void Main(string[] args)
    {
        Console.WriteLine("=== C# Date and Time Formatting Demo ===\n");

        try
        {
            StandardFormatStrings();
            CustomFormatStrings();
            ComplexCustomFormats();
            CultureSpecificFormatting();
            TimeSpanFormatting();
            StringParsingWithFormats();
            AdvancedFormattingScenarios();
            DateTimeSerialization();
            PerformanceConsiderations();

            Console.WriteLine("\nAll date and time formatting examples completed successfully!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error in time formatting demo: {ex.Message}");
        }
    }
}
代码csharp中等

时间解析和转换

C#中的高级日期时间解析、时区转换和时区感知操作

难度

6/10

预计时间

30 min

标签

csharp, datetime, parsing, timezone, conversion, windows

前置条件

C# DateTime basics, TimeZoneInfo, Globalization

csharp
using System;
using System.Globalization;

class TimeParsingConversion
{
    // 1. Basic date parsing methods
    public static void BasicDateParsing()
    {
        Console.WriteLine("=== Basic Date Parsing ===");

        string[] dateStrings = {
            "2024-12-25",
            "25/12/2024",
            "December 25, 2024",
            "2024-12-25 14:30:45",
            "2:30 PM",
            "2024-12-25T14:30:45",
            "invalid date",
            "31/02/2024"
        };

        Console.WriteLine("Parsing with TryParse:");
        foreach (string dateStr in dateStrings)
        {
            Console.Write($"'{dateStr}' -> ");

            if (DateTime.TryParse(dateStr, out DateTime parsed))
            {
                Console.WriteLine($"Success: {parsed:yyyy-MM-dd HH:mm:ss}");
            }
            else
            {
                Console.WriteLine("Failed");
            }
        }

        Console.WriteLine("\nParsing with Parse (throws exception):");
        foreach (string dateStr in dateStrings.Take(3)) // Only first 3 valid ones
        {
            try
            {
                DateTime parsed = DateTime.Parse(dateStr);
                Console.WriteLine($"'{dateStr}' -> {parsed:yyyy-MM-dd HH:mm:ss}");
            }
            catch (FormatException ex)
            {
                Console.WriteLine($"'{dateStr}' -> Error: {ex.Message}");
            }
        }
    }

    // 2. Parsing with specific formats
    public static void ParseWithSpecificFormats()
    {
        Console.WriteLine("\n=== Parsing with Specific Formats ===");

        string[] dateStrings = {
            "2024-12-25",
            "25/12/2024",
            "12-25-2024",
            "25.12.2024",
            "December 25, 2024",
            "Dec 25 2024",
            "2024年12月25日"
        };

        string[] formats = {
            "yyyy-MM-dd",
            "dd/MM/yyyy",
            "MM-dd-yyyy",
            "dd.MM.yyyy",
            "MMMM dd, yyyy",
            "MMM dd yyyy",
            "yyyy年MM月dd日"
        };

        Console.WriteLine("Parsing with TryParseExact:");
        foreach (string dateStr in dateStrings)
        {
            Console.WriteLine($"\nTrying '{dateStr}':");

            foreach (string format in formats)
            {
                if (DateTime.TryParseExact(dateStr, format, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime parsed))
                {
                    Console.WriteLine($"  Format '{format}' -> {parsed:yyyy-MM-dd}");
                }
            }

            // Try multiple formats at once
            if (DateTime.TryParseExact(dateStr, formats, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime multiParsed))
            {
                Console.WriteLine($"  Multiple format success -> {multiParsed:yyyy-MM-dd}");
            }
        }
    }

    // 3. Culture-aware parsing
    public static void CultureAwareParsing()
    {
        Console.WriteLine("\n=== Culture-Aware Parsing ===");

        string dateString = "12/25/2024";

        CultureInfo[] cultures = {
            CultureInfo.GetCultureInfo("en-US"),  // MM/dd/yyyy
            CultureInfo.GetCultureInfo("en-GB"),  // dd/MM/yyyy
            CultureInfo.GetCultureInfo("fr-FR"),  // dd/MM/yyyy
            CultureInfo.GetCultureInfo("de-DE")   // dd.MM.yyyy
        };

        Console.WriteLine($"Parsing '{dateString}' with different cultures:");
        foreach (var culture in cultures)
        {
            if (DateTime.TryParse(dateString, culture, DateTimeStyles.None, out DateTime parsed))
            {
                Console.WriteLine($"{culture.Name,-8}: {parsed:yyyy-MM-dd}");
            }
            else
            {
                Console.WriteLine($"{culture.Name,-8}: Failed");
            }
        }

        // Example with month names
        string frenchDate = "25 décembre 2024";
        var frenchCulture = CultureInfo.GetCultureInfo("fr-FR");

        Console.WriteLine($"\nParsing '{frenchDate}' with French culture:");
        if (DateTime.TryParse(frenchDate, frenchCulture, DateTimeStyles.None, out DateTime frenchParsed))
        {
            Console.WriteLine($"Success: {frenchParsed:yyyy-MM-dd}");
        }

        // Example with AM/PM
        string timeString = "2:30 PM";
        var usCulture = CultureInfo.GetCultureInfo("en-US");

        Console.WriteLine($"\nParsing '{timeString}' with US culture:");
        if (DateTime.TryParse(timeString, usCulture, DateTimeStyles.None, out DateTime timeParsed))
        {
            Console.WriteLine($"Success: {timeParsed:HH:mm:ss}");
        }
    }

    // 4. DateTime conversion between types
    public static void DateTimeTypeConversion()
    {
        Console.WriteLine("\n=== DateTime Type Conversion ===");

        // DateTime to DateTimeOffset
        DateTime local = DateTime.Now;
        DateTimeOffset dateTimeOffset = new DateTimeOffset(local, TimeZoneInfo.Local.GetUtcOffset(local));

        Console.WriteLine($"DateTime: {local:yyyy-MM-dd HH:mm:ss}");
        Console.WriteLine($"DateTimeOffset: {dateTimeOffset:yyyy-MM-dd HH:mm:ss zzz}");

        // DateTimeOffset to DateTime
        DateTime fromOffset = dateTimeOffset.DateTime;
        DateTime fromOffsetUtc = dateTimeOffset.UtcDateTime;
        DateTime fromOffsetLocal = dateTimeOffset.LocalDateTime;

        Console.WriteLine($"\nFrom DateTimeOffset:");
        Console.WriteLine($"DateTime: {fromOffset:yyyy-MM-dd HH:mm:ss}");
        Console.WriteLine($"UtcDateTime: {fromOffsetUtc:yyyy-MM-dd HH:mm:ss}");
        Console.WriteLine($"LocalDateTime: {fromOffsetLocal:yyyy-MM-dd HH:mm:ss}");

        // DateOnly and TimeOnly (.NET 6+)
        Console.WriteLine("\nDateOnly and TimeOnly:");
        DateOnly dateOnly = DateOnly.FromDateTime(local);
        TimeOnly timeOnly = TimeOnly.FromDateTime(local);

        Console.WriteLine($"DateOnly: {dateOnly:yyyy-MM-dd}");
        Console.WriteLine($"TimeOnly: {timeOnly:HH:mm:ss}");

        // Convert back
        DateTime reconstructed = dateOnly.ToDateTime(timeOnly);
        Console.WriteLine($"Reconstructed: {reconstructed:yyyy-MM-dd HH:mm:ss}");
    }

    // 5. Time zone operations
    public static void TimeZoneOperations()
    {
        Console.WriteLine("\n=== Time Zone Operations ===");

        // Get local time zone
        TimeZoneInfo localZone = TimeZoneInfo.Local;
        Console.WriteLine($"Local time zone: {localZone.DisplayName}");
        Console.WriteLine($"Standard name: {localZone.StandardName}");
        Console.WriteLine($"Daylight name: {localZone.DaylightName}");
        Console.WriteLine($"UTC offset: {localZone.GetUtcOffset(DateTime.Now)}");

        // Get UTC time zone
        TimeZoneInfo utcZone = TimeZoneInfo.Utc;
        Console.WriteLine($"\nUTC time zone: {utcZone.DisplayName}");

        // Convert between time zones
        DateTime localTime = DateTime.Now;
        DateTime utcTime = TimeZoneInfo.ConvertTimeToUtc(localTime);
        DateTime backToLocal = TimeZoneInfo.ConvertTimeFromUtc(utcTime, localZone);

        Console.WriteLine($"\nTime zone conversions:");
        Console.WriteLine($"Local time: {localTime:yyyy-MM-dd HH:mm:ss}");
        Console.WriteLine($"UTC time: {utcTime:yyyy-MM-dd HH:mm:ss}");
        Console.WriteLine($"Back to local: {backToLocal:yyyy-MM-dd HH:mm:ss}");

        // Convert to specific time zone
        TimeZoneInfo easternZone = TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time");
        DateTime easternTime = TimeZoneInfo.ConvertTime(localTime, easternZone);

        Console.WriteLine($"\nEastern Time: {easternTime:yyyy-MM-dd HH:mm:ss} ({easternZone.DisplayName})");

        // List available time zones
        Console.WriteLine("\nAvailable time zones (first 10):");
        var timeZones = TimeZoneInfo.GetSystemTimeZones().Take(10);
        foreach (var zone in timeZones)
        {
            Console.WriteLine($"  {zone.Id}: {zone.DisplayName}");
        }
    }

    // 6. DateTimeOffset operations
    public static void DateTimeOffsetOperations()
    {
        Console.WriteLine("\n=== DateTimeOffset Operations ===");

        // Create DateTimeOffset
        DateTimeOffset localOffset = DateTimeOffset.Now;
        DateTimeOffset utcOffset = DateTimeOffset.UtcNow;
        DateTimeOffset specificOffset = new DateTimeOffset(2024, 12, 25, 14, 30, 0, TimeSpan.FromHours(-5));

        Console.WriteLine($"Local offset: {localOffset:yyyy-MM-dd HH:mm:ss zzz}");
        Console.WriteLine($"UTC offset: {utcOffset:yyyy-MM-dd HH:mm:ss zzz}");
        Console.WriteLine($"Specific offset (-5): {specificOffset:yyyy-MM-dd HH:mm:ss zzz}");

        // Convert between offsets
        DateTimeOffset converted = TimeZoneInfo.ConvertTime(specificOffset, TimeZoneInfo.Local);
        Console.WriteLine($"Converted to local: {converted:yyyy-MM-dd HH:mm:ss zzz}");

        // Arithmetic operations
        DateTimeOffset plusDay = localOffset.AddDays(1);
        DateTimeOffset plusHours = localOffset.AddHours(5);

        Console.WriteLine($"\nArithmetic:");
        Console.WriteLine($"Plus 1 day: {plusDay:yyyy-MM-dd HH:mm:ss zzz}");
        Console.WriteLine($"Plus 5 hours: {plusHours:yyyy-MM-dd HH:mm:ss zzz}");

        // Comparison
        Console.WriteLine($"\nComparison:");
        Console.WriteLine($"localOffset > utcOffset: {localOffset > utcOffset}");
        Console.WriteLine($"specificOffset.UtcDateTime: {specificOffset.UtcDateTime:yyyy-MM-dd HH:mm:ss}");
    }

    // 7. Daylight saving time handling
    public static void DaylightSavingTime()
    {
        Console.WriteLine("\n=== Daylight Saving Time Handling ===");

        TimeZoneInfo localZone = TimeZoneInfo.Local;

        // Check if DST is supported
        Console.WriteLine($"DST supported: {localZone.SupportsDaylightSavingTime}");

        if (localZone.SupportsDaylightSavingTime)
        {
            // Get DST rules
            var adjustmentRules = localZone.GetAdjustmentRules();
            if (adjustmentRules.Length > 0)
            {
                var currentRule = adjustmentRules[adjustmentRules.Length - 1]; // Most recent rule
                Console.WriteLine($"\nDST adjustment rule:");
                Console.WriteLine($"Daylight start: {currentRule.DaylightTransitionStart}");
                Console.WriteLine($"Daylight end: {currentRule.DaylightTransitionEnd}");
                Console.WriteLine($"Daylight delta: {currentRule.DaylightDelta}");
            }

            // Check if specific date is DST
            DateTime summerDate = new DateTime(2024, 7, 15);
            DateTime winterDate = new DateTime(2024, 1, 15);

            Console.WriteLine($"\nDST status:");
            Console.WriteLine($"{summerDate:yyyy-MM-dd} is DST: {localZone.IsDaylightSavingTime(summerDate)}");
            Console.WriteLine($"{winterDate:yyyy-MM-dd} is DST: {localZone.IsDaylightSavingTime(winterDate)}");

            // Get UTC offsets
            TimeSpan summerOffset = localZone.GetUtcOffset(summerDate);
            TimeSpan winterOffset = localZone.GetUtcOffset(winterDate);

            Console.WriteLine($"\nUTC offsets:");
            Console.WriteLine($"Summer offset: {summerOffset}");
            Console.WriteLine($"Winter offset: {winterOffset}");
            Console.WriteLine($"DST difference: {summerOffset - winterOffset}");
        }
    }

    // 8. Parsing and conversion challenges
    public static void ParsingAndConversionChallenges()
    {
        Console.WriteLine("\n=== Parsing and Conversion Challenges ===");

        // Challenge 1: Ambiguous dates during DST transition
        Console.WriteLine("Challenge 1: Ambiguous dates");
        var dstZone = TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time");

        // Create ambiguous time (fall back)
        DateTime ambiguous = new DateTime(2024, 11, 3, 1, 30, 0); // During DST fall back

        Console.WriteLine($"Ambiguous time: {ambiguous:yyyy-MM-dd HH:mm:ss}");

        try
        {
            var ambiguousOffset = new DateTimeOffset(ambiguous, dstZone.GetUtcOffset(ambiguous));
            Console.WriteLine($"Resolved as: {ambiguousOffset:yyyy-MM-dd HH:mm:ss zzz}");
        }
        catch (ArgumentException ex)
        {
            Console.WriteLine($"Ambiguity error: {ex.Message}");
        }

        // Challenge 2: Invalid dates during DST transition
        Console.WriteLine("\nChallenge 2: Invalid dates");

        // Create invalid time (spring forward)
        DateTime invalid = new DateTime(2024, 3, 10, 2, 30, 0); // During DST spring forward

        Console.WriteLine($"Invalid time: {invalid:yyyy-MM-dd HH:mm:ss}");

        // Check if valid
        bool isValid = dstZone.IsValidTime(invalid);
        Console.WriteLine($"Is valid time: {isValid}");

        if (!isValid)
        {
            // Find next valid time
            TimeSpan utcOffset = dstZone.GetUtcOffset(invalid.AddDays(1));
            var nextValid = new DateTimeOffset(invalid, utcOffset).AddHours(1);
            Console.WriteLine($"Next valid time: {nextValid:yyyy-MM-dd HH:mm:ss zzz}");
        }

        // Challenge 3: Parsing Unix timestamps
        Console.WriteLine("\nChallenge 3: Unix timestamps");

        long unixTimestamp = 1703568000; // December 26, 2023 00:00:00 UTC
        DateTime fromUnix = DateTimeOffset.FromUnixTimeSeconds(unixTimestamp).DateTime;
        Console.WriteLine($"Unix timestamp {unixTimestamp} -> {fromUnix:yyyy-MM-dd HH:mm:ss}");

        // Convert to Unix timestamp
        long toUnix = ((DateTimeOffset)DateTime.UtcNow).ToUnixTimeSeconds();
        Console.WriteLine($"Current Unix timestamp: {toUnix}");
    }

    // 9. Real-world parsing scenarios
    public static void RealWorldParsingScenarios()
    {
        Console.WriteLine("\n=== Real-world Parsing Scenarios ===");

        // Scenario 1: Log file timestamp parsing
        string[] logTimestamps = {
            "2024-12-25 14:30:45.123",
            "25/12/2024 14:30:45",
            "Wed Dec 25 14:30:45 2024",
            "20241225143045"
        };

        Console.WriteLine("Log timestamp parsing:");
        string[] logFormats = {
            "yyyy-MM-dd HH:mm:ss.fff",
            "dd/MM/yyyy HH:mm:ss",
            "ddd MMM dd HH:mm:ss yyyy",
            "yyyyMMddHHmmss"
        };

        foreach (string timestamp in logTimestamps)
        {
            if (DateTime.TryParseExact(timestamp, logFormats, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime parsed))
            {
                Console.WriteLine($"'{timestamp}' -> {parsed:yyyy-MM-dd HH:mm:ss.fff}");
            }
        }

        // Scenario 2: International date formats
        Console.WriteLine("\nInternational date formats:");
        string[] internationalDates = {
            "25/12/2024",     // European
            "12/25/2024",     // US
            "25.12.2024",     // German
            "2024年12月25日"   // Japanese
        };

        CultureInfo[] cultures = {
            CultureInfo.GetCultureInfo("en-GB"),
            CultureInfo.GetCultureInfo("en-US"),
            CultureInfo.GetCultureInfo("de-DE"),
            CultureInfo.GetCultureInfo("ja-JP")
        };

        for (int i = 0; i < internationalDates.Length; i++)
        {
            string dateStr = internationalDates[i];
            var culture = cultures[i];

            if (DateTime.TryParse(dateStr, culture, DateTimeStyles.None, out DateTime parsed))
            {
                Console.WriteLine($"'{dateStr}' ({culture.Name}) -> {parsed:yyyy-MM-dd}");
            }
        }

        // Scenario 3: Relative time parsing
        Console.WriteLine("\nRelative time parsing:");
        string[] relativeTimes = { "2 hours ago", "yesterday", "last week", "in 3 days", "next month" };

        foreach (string relative in relativeTimes)
        {
            DateTime? parsed = ParseRelativeTime(relative);
            if (parsed.HasValue)
            {
                Console.WriteLine($"'{relative}' -> {parsed.Value:yyyy-MM-dd HH:mm:ss}");
            }
            else
            {
                Console.WriteLine($"'{relative}' -> Not implemented");
            }
        }
    }

    // 10. Performance optimization
    public static void PerformanceOptimization()
    {
        Console.WriteLine("\n=== Performance Optimization ===");

        const int iterations = 10000;
        string testDate = "2024-12-25 14:30:45";
        string[] testDates = Enumerable.Repeat(testDate, iterations).ToArray();

        var stopwatch = System.Diagnostics.Stopwatch.StartNew();

        // Method 1: DateTime.Parse
        stopwatch.Restart();
        foreach (string dateStr in testDates)
        {
            DateTime.Parse(dateStr);
        }
        stopwatch.Stop();
        Console.WriteLine($"DateTime.Parse x {iterations:N0}: {stopwatch.ElapsedMilliseconds}ms");

        // Method 2: DateTime.TryParse (safe)
        stopwatch.Restart();
        foreach (string dateStr in testDates)
        {
            DateTime.TryParse(dateStr, out _);
        }
        stopwatch.Stop();
        Console.WriteLine($"DateTime.TryParse x {iterations:N0}: {stopwatch.ElapsedMilliseconds}ms");

        // Method 3: TryParseExact with pre-defined format
        stopwatch.Restart();
        foreach (string dateStr in testDates)
        {
            DateTime.TryParseExact(dateStr, "yyyy-MM-dd HH:mm:ss",
                                 CultureInfo.InvariantCulture, DateTimeStyles.None, out _);
        }
        stopwatch.Stop();
        Console.WriteLine($"DateTime.TryParseExact x {iterations:N0}: {stopwatch.ElapsedMilliseconds}ms");

        // Method 4: Custom parsing (if format is known)
        stopwatch.Restart();
        foreach (string dateStr in testDates)
        {
            CustomParseDateTime(dateStr);
        }
        stopwatch.Stop();
        Console.WriteLine($"Custom parse x {iterations:N0}: {stopwatch.ElapsedMilliseconds}ms");
    }

    // Helper methods
    static DateTime? ParseRelativeTime(string relative)
    {
        // Simplified relative time parsing
        DateTime now = DateTime.Now;
        relative = relative.ToLowerInvariant();

        if (relative == "yesterday")
            return now.AddDays(-1);
        else if (relative == "today")
            return now;
        else if (relative == "tomorrow")
            return now.AddDays(1);
        else if (relative.StartsWith("last "))
        {
            if (relative.Contains("week"))
                return now.AddDays(-7);
            else if (relative.Contains("month"))
                return now.AddMonths(-1);
            else if (relative.Contains("year"))
                return now.AddYears(-1);
        }
        else if (relative.StartsWith("next "))
        {
            if (relative.Contains("week"))
                return now.AddDays(7);
            else if (relative.Contains("month"))
                return now.AddMonths(1);
            else if (relative.Contains("year"))
                return now.AddYears(1);
        }
        else if (relative.EndsWith(" ago"))
        {
            string[] parts = relative.Split(' ');
            if (parts.Length == 2 && int.TryParse(parts[0], out int amount))
            {
                if (relative.Contains("hour"))
                    return now.AddHours(-amount);
                else if (relative.Contains("day"))
                    return now.AddDays(-amount);
            }
        }
        else if (relative.StartsWith("in "))
        {
            string[] parts = relative.Split(' ');
            if (parts.Length == 2 && int.TryParse(parts[1], out int amount))
            {
                if (relative.Contains("hour"))
                    return now.AddHours(amount);
                else if (relative.Contains("day"))
                    return now.AddDays(amount);
            }
        }

        return null;
    }

    static DateTime CustomParseDateTime(string dateTimeString)
    {
        // Fast custom parsing for known format "yyyy-MM-dd HH:mm:ss"
        int year = int.Parse(dateTimeString.Substring(0, 4));
        int month = int.Parse(dateTimeString.Substring(5, 2));
        int day = int.Parse(dateTimeString.Substring(8, 2));
        int hour = int.Parse(dateTimeString.Substring(11, 2));
        int minute = int.Parse(dateTimeString.Substring(14, 2));
        int second = int.Parse(dateTimeString.Substring(17, 2));

        return new DateTime(year, month, day, hour, minute, second);
    }

    static void Main(string[] args)
    {
        Console.WriteLine("=== C# Time Parsing and Conversion Demo ===\n");

        try
        {
            BasicDateParsing();
            ParseWithSpecificFormats();
            CultureAwareParsing();
            DateTimeTypeConversion();
            TimeZoneOperations();
            DateTimeOffsetOperations();
            DaylightSavingTime();
            ParsingAndConversionChallenges();
            RealWorldParsingScenarios();
            PerformanceOptimization();

            Console.WriteLine("\nAll time parsing and conversion examples completed successfully!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error in time parsing demo: {ex.Message}");
        }
    }
}

工具

经常与该案例搭配使用的工具

相关内容

相关案例集合

相关内容

相关专题

专题

容器发布前的 Dockerfile 与环境配置审查

检查 Dockerfile 规则、镜像引用格式与环境变量重复键,解释预发布和生产配置差异,形成可核对的容器发布记录。

专题

域名上线前的 DNS、DNSSEC 与 HTTPS 验收

先拟定 DNS 区域记录,再核对在线解析、DNSSEC 委派和实际提供的 HTTPS 证书,为域名上线留下可复核的依据。

专题

重复日历与 ICS 日程安排

跨时区规划并验证重复会议,处理工作日、节假日、冲突和 ICS 导出要求。

专题

API Mock 夹具生成与审阅

生成可重复的 Mock 负载,构造符合格式的边界值,发现易混淆字段名,并在共享临时 Mock 服务前完成复核。

首页
工具3208
案例593
可视化469
文件查看器103
专题237
标签333
图像、音频与视频657

图像、音频、视频处理、转换与优化工具

数学、日期与金融646

计算器、数值计算、日期逻辑、统计与金融工具

设计与颜色298

颜色、版式、图形、视觉样式与设计辅助工具

文本与写作209

写作、清洗、格式化、提取与文本分析工具

开发与 Web193

开发者工具、网络处理、Web 调试与自动化辅助工具

转换与编码175

格式、文件、压缩包、单位与编码转换工具

本地习惯记录的备份、恢复演练与分享前检查
长文改编 X 串文与 LinkedIn 帖子的事实复核与交付
Markdown 互动课件审校、离线演示与交付
小房间家具布局复核与搬入方案交付
FLAC/WAV 无损音源疑点筛查与证据交付

© 2026 Elysia Tools. 保留所有权利。

文档价格关于我们服务条款隐私政策Cookie 政策联系我们

Media

AVI转MP4转换器

将AVI视频文件转换为MP4格式

Media

MP4转AVI转换器

将MP4视频文件转换为AVI格式

Media

批量视频转换器

批量转换多个视频文件格式,支持 MP4、WebM、MKV、AVI、MOV、FLV,支持质量设置和批量处理

Media

视频剪辑器

精确剪辑视频片段,支持多种格式和质量设置

Media

视频转APNG

将视频片段转换为APNG(动画PNG)格式,支持透明度且质量优于GIF

Media

视频转GIF优化版

将视频转换为优化后的GIF格式,支持高级压缩设置

Media

视频转图片序列

将视频帧提取为图片序列,支持自定义帧率、质量和输出格式

Media

视频修剪

快速修剪视频片段 - 使用快速无损处理从视频中提取片段

C#

Windows 桌面端功能 - C# 示例

Windows平台C#桌面端功能示例,包括文件对话框、消息框和系统托盘集成

测试

BDD with Cucumber - 行为驱动开发实践

全面的 Cucumber BDD 示例,包括功能文件、步骤定义、数据表格、钩子和高级 BDD 模式,用于协作开发

媒体

SVG示例

可缩放矢量图形(SVG)示例,展示各种SVG功能和技术

C#

Windows 图像处理 - C# 示例

Windows平台C#图像处理示例,包括图像操作、过滤、格式转换和高级计算机视觉操作

C++

Windows C++ 序列化示例

Windows C++ 数据序列化示例,包括JSON序列化/反序列化和XML解析

媒体

二维码示例

用于测试二维码读取和生成工具的示例二维码图像