Reliable Methods to Retrieve Build Dates in C# Applications

Introduction

In software development, displaying application build information to users is a common requirement. Traditional build numbers (e.g., 1.0.8.4321), while meaningful to developers, are often confusing for end-users. Users typically prefer date-based references, such as "last Thursday's build." Therefore, presenting build dates in a format like "Application built on October 15, 2023" provides a more intuitive user experience.

Core Solution: Reading Linker Timestamps from PE Headers

The most reliable approach involves reading linker timestamps embedded in the Portable Executable (PE) header of the executable file. This method directly accesses structural information from the binary file without relying on additional compile-time configurations.

Here is a complete C# extension method implementation for extracting build dates from assemblies:

public static DateTime GetLinkerTime(this Assembly assembly, TimeZoneInfo target = null)
{
    var filePath = assembly.Location;
    const int c_PeHeaderOffset = 60;
    const int c_LinkerTimestampOffset = 8;

    var buffer = new byte[2048];

    using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
        stream.Read(buffer, 0, 2048);

    var offset = BitConverter.ToInt32(buffer, c_PeHeaderOffset);
    var secondsSince1970 = BitConverter.ToInt32(buffer, offset + c_LinkerTimestampOffset);
    var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

    var linkTimeUtc = epoch.AddSeconds(secondsSince1970);

    var tz = target ?? TimeZoneInfo.Local;
    var localTime = TimeZoneInfo.ConvertTimeFromUtc(linkTimeUtc, tz);

    return localTime;
}

Code Analysis and Implementation Principles

This method operates based on the PE file format specification. The PE header contains a timestamp field that records when the linker created the executable file. The implementation follows these steps:

1. Locate PE Header Offset: Read the PE header starting position at file offset 60 bytes (c_PeHeaderOffset).
2. Read Timestamp: Extract the linker timestamp from 8 bytes after the PE header start (c_LinkerTimestampOffset), representing seconds since January 1, 1970.
3. Time Conversion: Convert the Unix timestamp to a DateTime object and adjust it to the specified or local time zone.

Usage is straightforward:

var linkTimeLocal = Assembly.GetExecutingAssembly().GetLinkerTime();
Console.WriteLine($"Application built on: {linkTimeLocal:yyyy-MM-dd HH:mm:ss}");

Compatibility Considerations

It is important to note that this method works correctly in .NET Core 1.0 but may encounter issues in .NET Core 1.1 and later versions. In some cases, it may return random years within the 1900-2020 range. This occurs because the .NET Core build process has changed, and linker timestamps may no longer accurately reflect actual build times.

Alternative Approaches Comparison

Pre-Build Event Method

Another common approach involves generating a build date file during pre-build events:

echo %date% %time% > "$(ProjectDir)\Resources\BuildDate.txt"

This file is then embedded as a resource in the assembly. While simple and direct, this method requires manual resource management and may be unreliable in certain build environments.

Automatic Version Number Conversion

Utilizing Visual Studio's automatic versioning feature is also an option. When AssemblyVersion includes wildcards (e.g., "1.0.*"), build numbers are automatically generated based on dates:

[assembly: AssemblyVersion("1.0.*")]

The version number can be converted to a date using the following code:

var version = Assembly.GetEntryAssembly().GetName().Version;
var buildDateTime = new DateTime(2000, 1, 1).Add(new TimeSpan(
    TimeSpan.TicksPerDay * version.Build + 
    TimeSpan.TicksPerSecond * 2 * version.Revision));

This method relies on specific version number generation rules and may not suit all project requirements.

Practical Implementation Recommendations

When selecting a build date display strategy, consider the following factors:

1. Target Framework: The PE header method is generally reliable for traditional .NET Framework projects. For .NET Core/.NET 5+ projects, alternative approaches may be necessary.
2. Build Environment: In continuous integration/continuous deployment (CI/CD) environments, injecting build dates through build scripts might be preferable.
3. Accuracy Requirements: If precise build timing is critical, consider build-time generation methods rather than runtime parsing.
4. Maintenance Overhead: Simpler solutions are typically easier to maintain and debug.

Conclusion

Multiple methods exist for retrieving and displaying application build dates, each with its own advantages and limitations. Reading linker timestamps from PE headers offers the most direct technical solution but may face compatibility challenges in newer .NET versions. Pre-build events and resource embedding provide greater flexibility but require additional configuration management. Automatic version number conversion offers a built-in solution with limited functionality.

In practical development, choose an approach based on specific project needs and technology stack. For production environments requiring high reliability, consider combining multiple methods or explicitly injecting build date information through build pipelines. Regardless of the chosen method, ensuring accurate and consistent build date information is essential for software maintenance and user support.