How to Get AssemblyFileVersion in C#

By the end of this page, you will understand the difference between AssemblyVersion and AssemblyFileVersion, how to read file version information in C#, when to use reflection versus file metadata APIs, and how this is commonly handled in real applications.

AssemblyVersion and AssemblyFileVersion are related, but they serve different purposes.

• AssemblyVersion is part of the assembly's identity.
• AssemblyFileVersion is file metadata stored in the compiled executable or DLL.

In C#, you usually read them in different ways:

• AssemblyVersion is commonly accessed through Assembly.GetName().Version
• AssemblyFileVersion is commonly accessed through:
  • the AssemblyFileVersionAttribute, or
  • FileVersionInfo

Why this matters:

• You may want to show a version string in an About dialog.
• You may log the exact deployed build number.
• Support teams may need the file version to identify a release.
• CI/CD systems often increment file version independently from assembly identity.

A key point for beginners: AssemblyFileVersion is not the same thing as AssemblyVersion. Even if both are defined in the same project file, they can contain different values and are used for different reasons.

Think of an assembly like a book:

• AssemblyVersion is the edition number used by libraries and the runtime to identify the book.
• AssemblyFileVersion is the printing number stamped on the physical copy.

Two books might be the same edition, but printed at different times with different print numbers. In the same way, an assembly can keep the same AssemblyVersion while the AssemblyFileVersion changes for each build.

The two most common ways to get AssemblyFileVersion are shown below.

Option 1: Read the AssemblyFileVersionAttribute

using System;
using System.Reflection;

class Program
{
    static void Main()
    {
        Assembly assembly = Assembly.GetEntryAssembly();
        var attribute = assembly.GetCustomAttribute<AssemblyFileVersionAttribute>();

        string fileVersion = attribute?.Version;
        Console.WriteLine(fileVersion);
    }
}

How it works

• GetEntryAssembly() gets the main executable assembly.
• GetCustomAttribute<AssemblyFileVersionAttribute>() reads the attribute applied to that assembly.
• attribute.Version contains the file version string.

Option 2: Use FileVersionInfo

using System;
using System.Diagnostics;
using System.Reflection;

class Program
{
      ()
    {
         path = Assembly.GetEntryAssembly().Location;
        FileVersionInfo info = FileVersionInfo.GetVersionInfo(path);

        Console.WriteLine(info.FileVersion);
    }
}

Consider this example:

using System;
using System.Reflection;

class Program
{
    static void Main()
    {
        Assembly assembly = Assembly.GetEntryAssembly();
        var attribute = assembly.GetCustomAttribute<AssemblyFileVersionAttribute>();

        Console.WriteLine(attribute?.Version ?? "No file version found");
    }
}

Step by step:

1. Assembly.GetEntryAssembly() gets the assembly that started the process.
2. That result is stored in the assembly variable.
3. GetCustomAttribute<AssemblyFileVersionAttribute>() searches the assembly for the AssemblyFileVersion attribute.
4. If the attribute exists, it returns an object representing that attribute.
5. attribute?.Version safely reads the Version property.
6. If attribute is null, the null-coalescing operator ?? prints "No file version found" instead.

If your assembly contains this:

AssemblyFileVersion is commonly used in practical situations such as:

• About screens: showing the exact installed build in a desktop app.
• Logging: writing the deployed application version to logs during startup.
• Diagnostics: helping support teams identify which binary a customer is running.
• Update tools: comparing installed file versions with available releases.
• Installer validation: confirming the correct executable or DLL was deployed.

Example: startup logging

using System;
using System.Diagnostics;
using System.Reflection;

class Program
{
    static void Main()
    {
        string path = Assembly.GetEntryAssembly().Location;
        string version = FileVersionInfo.GetVersionInfo(path).FileVersion;

        Console.WriteLine($"Starting app version {version}");
    }
}

In real projects, developers usually wrap version access in a helper method or service instead of repeating reflection code everywhere.

Common patterns

1. Centralized version helper

using System.Diagnostics;
using System.Reflection;

public static class AppVersion
{
    public static string GetFileVersion()
    {
        string path = Assembly.GetEntryAssembly()?.Location;
        if (string.IsNullOrEmpty(path))
            return "Unknown";

        return FileVersionInfo.GetVersionInfo(path).FileVersion ?? "Unknown";
    }
}

This makes version lookup easy to reuse.

2. Guard clauses

Real code often checks for null because GetEntryAssembly() can return null in some hosting scenarios.

Assembly assembly = Assembly.GetEntryAssembly();
if (assembly == null)
    return;

3. Fallback strategies

Here are some common mistakes beginners make.

Mistake 1: Assuming AssemblyVersion and AssemblyFileVersion are the same

Broken assumption:

Version version = Assembly.GetEntryAssembly().GetName().Version;
Console.WriteLine(version);

This reads AssemblyVersion, not AssemblyFileVersion.

Fix

Use AssemblyFileVersionAttribute or FileVersionInfo.

Mistake 2: Forgetting that GetEntryAssembly() can be null

Broken code:

string path = Assembly.GetEntryAssembly().Location;

If GetEntryAssembly() is null, this throws an exception.

Fix

Assembly assembly = Assembly.GetEntryAssembly();
if (assembly != null)
{
     path = assembly.Location;
}

Here is a quick comparison of the main version-related values in .NET.

Quick reference

Get AssemblyVersion

Version version = Assembly.GetEntryAssembly().GetName().Version;

Get AssemblyFileVersion from attribute

string fileVersion = Assembly
    .GetEntryAssembly()?
    .GetCustomAttribute<AssemblyFileVersionAttribute>()?
    .Version;

Get AssemblyFileVersion from file metadata

string path = Assembly.GetEntryAssembly()?.Location;
string fileVersion = FileVersionInfo.GetVersionInfo(path).FileVersion;

Rules to remember

• AssemblyVersion is assembly identity.
• AssemblyFileVersion is file metadata.
• They can be different.
• GetEntryAssembly() may return null.
• For class libraries, use typeof(MyType).Assembly if you want that library's version.

Useful namespaces

How do I get AssemblyFileVersion in C#?

Use either AssemblyFileVersionAttribute through reflection or FileVersionInfo with the assembly file path.

What is the difference between AssemblyVersion and AssemblyFileVersion?

AssemblyVersion is used for assembly identity and binding. AssemblyFileVersion is file metadata used mainly for diagnostics and file properties.

Why does Assembly.GetName().Version not return the file version?

Because it returns the assembly identity version, which comes from AssemblyVersion, not the file version resource.

Should I use FileVersionInfo or AssemblyFileVersionAttribute?

Use AssemblyFileVersionAttribute for direct attribute access. Use FileVersionInfo when you specifically want the file's version resource.

Can AssemblyFileVersion be different from AssemblyVersion?

• AssemblyVersion - Closely related because it is often confused with file version.
• AssemblyInformationalVersion - Useful when you need a display-friendly version string.
• Reflection in C# - Needed to read custom attributes from assemblies.
• Attributes in C# - AssemblyFileVersion is stored as an attribute.
• FileVersionInfo - The .NET API for reading Win32 version resource metadata.
• GetEntryAssembly vs GetExecutingAssembly - Important for choosing the correct assembly.
• Version class in .NET - Useful for understanding structured version numbers.