Elysia Tools

Browse tools, examples, visual explainers, and topic guides from one clear workspace.

Top Categories

Hubs

Language
ZHDERUPTENFRES

Elysia Tools

Navigation

C#

Windows Date and Time - C# Samples

Comprehensive C# date and time processing examples for Windows platform including DateTime, TimeSpan, TimeZone, and calendar operations

Samples

Entries inside this sample collection

CodecsharpSimple

Getting Current Date and Time

Various methods to get current date, time, and perform basic time calculations in C#

Difficulty

2/10

Estimated time

15 min

Tags

csharp, datetime, time, windows

Prerequisites

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

Date and Time Formatting

Comprehensive date and time formatting options including culture-specific formats, custom patterns, and string parsing

Difficulty

5/10

Estimated time

25 min

Tags

csharp, datetime, formatting, culture, localization, windows

Prerequisites

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

Time Parsing and Conversion

Advanced date time parsing, timezone conversion, and time zone aware operations in C#

Difficulty

6/10

Estimated time

30 min

Tags

csharp, datetime, parsing, timezone, conversion, windows

Prerequisites

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

Tools

Tools frequently paired with this sample

Related

Related sample collections

Related

Related workflows

Hub

Date and Time Normalization and Deadline Calculation

Turn ambiguous or mixed-format date inputs into validated, timezone-aware, business-ready timestamps, deadlines, and duration facts.

Hub

Text Encoding, Width, Date, and Currency Conversion Workflow

Prepare imported or copied text for reuse by recovering its encoding, choosing a character-width convention, standardizing inline dates or currency, and selecting a final text representation.

Hub

Infer JSON Schema from Samples and Spreadsheets

Derive a reviewable JSON Schema draft from representative JSON samples or XLSX rows, then inspect types, requiredness, nulls, and outliers before treating it as a contract.

Hub

Stripe Promo Code Batch Review and Import Preflight

Review candidate codes, reconcile CSV and embedded importer data, inspect revisions and record a local dry run before approving a Stripe import package.

Home
Tools3212
Samples593
Visualizations471
Viewers103
Hubs239
Tags333
Images, Audio & Video657

Image, audio, and video processing, conversion, and optimization tools

Math, Date & Finance647

Calculators, numerics, date logic, statistics, and finance tools

Design & Color298

Color, layout, graphics, visual styling, and design helper tools

Text & Writing209

Writing, cleanup, formatting, extraction, and text analysis tools

Developer & Web193

Developer utilities, networking, web debugging, and automation helpers

Conversion & Encoding175

Format, file, archive, unit, and encoding conversion tools

Lead Generation Quiz Launch and Contact Handoff
Memorial Drafts: Family Review and Print Handoff
Private Habit Records: Backup, Restore and Sharing Review
Article to X and LinkedIn Drafts: Fact Review and Handoff
Markdown Interactive Deck Review and Offline Handoff

© 2026 Elysia Tools. All rights reserved.

DocsPricingAboutTerms of ServicePrivacy PolicyCookiesContact

Media

AVI to MP4 Converter

Convert AVI video files to MP4 format

Media

MP4 to AVI Converter

Convert MP4 video files to AVI format

Media

Batch Video Converter

Convert multiple video files between different formats like MP4, WebM, MKV, AVI, MOV with quality settings and batch processing

Media

Video Cutter

Cut and trim video clips with precision, supporting multiple formats and quality settings

Media

Video to APNG

Convert video clips to APNG (Animated PNG) format with transparency support and better quality than GIF

Media

Video to GIF Optimized

Convert videos to optimized GIF format with advanced compression settings

Media

Video to Image Sequence

Extract video frames as an image sequence with customizable frame rate, quality, and output format

Media

Video Trim

Quickly trim video clips - extract segments from videos with fast, lossless processing

C#

Windows Desktop Features - C# Samples

Comprehensive C# desktop features examples for Windows platform including file dialogs, message boxes, and system tray integration

Testing

BDD with Cucumber - Behavior Driven Development

Comprehensive Cucumber BDD examples including feature files, step definitions, data tables, hooks, and advanced BDD patterns for collaborative development

Media

SVG Samples

Scalable Vector Graphics (SVG) samples demonstrating various SVG features and techniques

C#

Windows Image Processing - C# Samples

Comprehensive C# image processing examples for Windows platform including image manipulation, filtering, format conversion, and advanced computer vision operations

C++

Windows Serialization C++ Samples

Windows C++ data serialization examples including JSON serialization/deserialization and XML parsing

Media

QR Code Samples

Sample QR code images for testing QR code reading and generation tools