DateTimeOffset.FromUnixTimeSeconds() Method in C#

The DateTimeOffset.FromUnixTimeSeconds() method in C# is used to convert a Unix timestamp (expressed as seconds since January 1, 1970, 00:00:00 UTC) to a DateTimeOffset value. This method is particularly useful when working with Unix-based systems or APIs that return timestamps in Unix format.

Syntax

Following is the syntax −

public static DateTimeOffset FromUnixTimeSeconds(long seconds);

Parameters

seconds: A Unix time, expressed as the number of seconds that have elapsed since 1970-01-01T00:00:00Z (January 1, 1970, at 12:00 AM UTC). This parameter accepts both positive and negative values.

Return Value

Returns a DateTimeOffset object that represents the date and time corresponding to the Unix timestamp, with an offset of +00:00 (UTC).

Using FromUnixTimeSeconds() with Positive Values

When the Unix timestamp is positive, it represents a date after January 1, 1970 −

using System;

public class Demo {
    public static void Main() {
        DateTimeOffset offset = DateTimeOffset.FromUnixTimeSeconds(20);
        Console.WriteLine("DateTimeOffset = {0}", offset);
        Console.WriteLine("DateTimeOffset (other format) = {0:dd} {0:y}, {0:hh}:{0:mm}:{0:ss}", offset);
        
        // Converting a more realistic timestamp
        DateTimeOffset newYear2021 = DateTimeOffset.FromUnixTimeSeconds(1609459200);
        Console.WriteLine("New Year 2021: {0}", newYear2021);
    }
}

The output of the above code is −

DateTimeOffset = 1/1/1970 12:00:20 AM +00:00
DateTimeOffset (other format) = 01 January 1970, 12:00:20
New Year 2021: 1/1/2021 12:00:00 AM +00:00

Using FromUnixTimeSeconds() with Negative Values

For dates before January 1, 1970, use negative Unix timestamp values −

using System;

public class Demo {
    public static void Main() {
        DateTimeOffset offset = DateTimeOffset.FromUnixTimeSeconds(-20);
        Console.WriteLine("DateTimeOffset = {0}", offset);
        Console.WriteLine("DateTimeOffset (other format) = {0:dd} {0:y}, {0:hh}:{0:mm}:{0:ss}", offset);
        
        // Converting a timestamp from 1960s
        DateTimeOffset sixties = DateTimeOffset.FromUnixTimeSeconds(-315619200);
        Console.WriteLine("Date in 1960: {0}", sixties);
    }
}

The output of the above code is −

DateTimeOffset = 12/31/1969 11:59:40 PM +00:00
DateTimeOffset (other format) = 31 December 1969, 11:59:40
Date in 1960: 1/1/1960 12:00:00 AM +00:00

Common Use Cases

This method is commonly used when −

• Working with REST APIs that return Unix timestamps

• Converting log file timestamps from Unix format

• Interfacing with databases that store dates as Unix timestamps

• Processing data from Unix-based systems

Example with Current Time Conversion

using System;

public class Demo {
    public static void Main() {
        // Get current Unix timestamp
        long currentUnixTime = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
        Console.WriteLine("Current Unix timestamp: " + currentUnixTime);
        
        // Convert back to DateTimeOffset
        DateTimeOffset convertedBack = DateTimeOffset.FromUnixTimeSeconds(currentUnixTime);
        Console.WriteLine("Converted back: " + convertedBack);
        
        // Demonstrate round-trip conversion
        Console.WriteLine("Original UTC Now: " + DateTimeOffset.UtcNow.ToString("yyyy-MM-dd HH:mm:ss"));
        Console.WriteLine("After round-trip: " + convertedBack.ToString("yyyy-MM-dd HH:mm:ss"));
    }
}

The output of the above code is −

Current Unix timestamp: 1704067200
Converted back: 1/1/2024 12:00:00 AM +00:00
Original UTC Now: 2024-01-01 00:00:00
After round-trip: 2024-01-01 00:00:00

Conclusion

The DateTimeOffset.FromUnixTimeSeconds() method provides a straightforward way to convert Unix timestamps to .NET's DateTimeOffset objects. This method handles both positive and negative values, making it versatile for working with dates before and after the Unix epoch, and is essential for integrating with Unix-based systems and APIs.