Windows Date and Time - C# Samples

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}");
        }
    }
}

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}");
        }
    }
}

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}");
        }
    }
}