Change Assembly Version in a compiled .NET assembly

Simple question... is there a way to change the Assembly Version of a compiled .NET assembly?

I'd actually be fine with a way to change the Assembly File Version.

You can use ILMerge:

ILMerge.exe Foo.dll /ver:1.2.3.4 /out:Foo2.dll

A valid reason to do this is to increment the assembly version in a build in you find breaking changes (using NDepend for example). That way if there are no breaking changes the assembly version stays the same, and you can patch released builds easily.

We always increment the file version, and that reflects the build number.

Old topic but here are my 5 dimes...

1. Disassemble > ildasm my.exe /output:my.il /metadata

2. Edit my.il to change version information. There are several places to look into:

• major:minor:revision:build - usually one occurrence
• major.minor.revision.build - several occurrences. The string is found in the comment section after the actual line. The version is a hexadecimal value in a byte array. Example:

.custom instance void [mscorlib]System.Reflection.AssemblyFileVersionAttribute::.ctor(string) = ( 01 00 07 35 2E 31 2E 33 2E 30 00 00 ) // ...5.1.3.0..

3. Edit my.res to change version information. Double click and edit with visual studio. Pretty straight forward procedure.

4. Assemble > ilasm my.il /res:my.res

Why do you want to do this? If it's so that another application can use it, you might want to look into assembly binding redirection instead.

It sounds like your process is heavy because you have to update multiple AssemblyInfo files. Have you considered sharing the same AssemblyInfo file between projects? Derik Whittaker gives a good example on how to do this.

Once you have a single file, you could then go the extra distance by having a build process update your single AssemblyInfo version using MSBuild or NAnt.

If you have formal testing and source control, the process becomes fairly straightforward. It starts with an understanding of who can change the diferent number segments of the version, and when. .net assemblies have 4 number segments (i.e. 1.0.0.1).

The first segment contains the Major Version number. This is set by upper management and indicates a major change in the UI or in the platform of the app. This should always be same number between the assembly version and the file version.

The second segment contains the Minor Version number, also known as the Feature Release number. This is set by Project Management and indicates that new features have been added to the app. This should always be same number between the assembly version and the file version.

The third segment contains the Build number. This is set by the testing group and indicates that the app is ready to be deployed. It is changed before bug fixes are released. When releasing a new build, testing resets the fourth segment to 0. This can be the same number between the assembly version and the file version, but is usually left at 0 for the assembly version to simplify patching existing deployments.

The fourth segment contains the Revision number. This set by the development group whenever they check new code into source control. This number would be included in the file version of the compiled DLL, but not in the assembly version.

I have found that this helps deployers, testers and developers keep track of the latest versions without stepping on each others toes. Unfortunatley, I have also worked with companies that used a static versioning system so that nobody really knew what the latest, best assembly was.

VerPatch, as referenced in this answer, is simple and effective.

Its strange folks have missed Resource Hacker. It is specially made for hacking file resources. So it will also help you edit assembly information including File Version.

using System;
using System.Windows.Forms;
using System.Diagnostics;

public class rh
{
	public static void Main()
	{
		Assembly_Changer("file_path.exe");
	}
	
    private static string rc()
    {
        string FileVersion = "6,8,0,1";
        return "1 VERSIONINFO"
        + "\n FILEVERSION " + FileVersion
        + "\n PRODUCTVERSION 0,0,0,0" 
        + "\n FILEOS 0x4"
        + "\n FILETYPE 0x1"
        + "\n {BLOCK \"StringFileInfo\"{BLOCK \"000004b0\"{}}BLOCK \"VarFileInfo\"{VALUE \"Translation\", 0x0000 0x04B0}}";
    }

    public static void Assembly_Changer(string exe)
    {
        System.IO.File.WriteAllText("details.rc", rc());
        process("reshacker.exe", "-open details.rc -save resources.res -action compile -log NUL");
        process("reshacker.exe", "-open \"" + exe + "\" -resource resources.res -save \"" + exe + "\" -action addoverwrite -mask \"Version info\"");
    }

    public static bool process(string filename, string args)
    {
        using (Process process = new Process())
        {
            process.StartInfo.FileName = filename;
            process.StartInfo.Arguments = args;
            process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
            process.Start();
            process.WaitForExit();
        }
        return true;
    }	
}