Can I automatically increment the file build version when using Visual Studio?

Question

I was just wondering how I could automatically increment the build (and version?) of my files using Visual Studio (2005).

If I look up the properties of say C:\Windows\notepad.exe, the Version tab gives "File version: 5.1.2600.2180". I would like to get these cool numbers in the version of my dll's too, not version 1.0.0.0, which let's face it is a bit dull.

I tried a few things, but it doesn't seem to be out-of-box functionality, or maybe I'm just looking in the wrong place (as usual).

I work with mainly web projects....

I looked at both:

1. http://www.codeproject.com/KB/dotnet/Auto_Increment_Version.aspx
2. http://www.codeproject.com/KB/dotnet/build_versioning.aspx

and I couldn't believe it so much effort to do something is standard practice.

EDIT: It does not work in VS2005 as far I can tell (http://www.codeproject.com/KB/dotnet/AutoIncrementVersion.aspx)

Mongrelize

wild card only seem to work for AssemblyVersion but not for AssemblyFileVersion in VS 2005 – Bethelbethena

Are there any solutions to this that work for C++ projects in VS2005? All the answers seem to rerlate to .Net. Related question. Thanks – Achene

In .Net Core projects AssemblyVersion auto-increment doesn't work by default. You need to add <Deterministic>False</Deterministic> to csproj. See Auto Versioning in Visual Studio 2017 (.NET Core) – Disaffirm

Answer 1

In visual Studio 2008, the following works.

Find the AssemblyInfo.cs file and find these 2 lines:

[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

You could try changing this to:

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

But this won't give you the desired result, you will end up with a Product Version of 1.0.* and a File Version of 1.0.0.0. Not what you want!

However, if you remove the second of these lines and just have:

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

Then the compiler will set the File Version to be equal to the Product Version and you will get your desired result of an automatically increment product and file version which are in sync. E.g. 1.0.3266.92689

Stalinist

This works as good as anything else, and works in VS2005. I was hoping for some rational number like 1.0.1.56 in lieu I get 1.0.3266.30135 but at least it increases (albeit by some random number :D) – Mongrelize

oh i just read it : it will automatically fill in the last two number with the date (in days from some point) and the time (half the seconds from midnight) – Mongrelize

Nice call on needing to remove the AssemblyFileVersion attribute to get this to work! – Winnah

I realise this is an old question, but wanted to add this comment for others who find their way to this answer. If you increment the AssemblyVersion, any project that uses your dll will need to be re-compiled. However, if you keep the AssemblyVersion the same and increment the AssemblyFileVersion by itself, then you can swap the new dll in without having to re-compile whatever is using it. So ask yourself this, is this just a new build, or am I releasing a new version? – Haily

@DD59 the 'Build' is number of days since Jan 1st 2000; the 'Revision' is seconds from midnight divided by 2 (not half-seconds, but two-second intervals). See here: https://mcmap.net/q/87762/-details-of-assembly-version – Bilk

@Haily but how would you increment the file version separate from the the assembly version if you can only have one of them specified? – Stome

@Stome I guess you couldn't iif you can only have one specified. But I've never seen a restriction like that. In the Assembly.cs or the SharedAssemblyInfo.cs (as the case may be), you can always specify both. – Haily

any ideas why this works locally in visual studio, but I seem to be getting 1.0.0.0 in TFS 2010 builds? – Commencement

How these 3266,92689 two numbers got generated in. 1.0.3266.92689 – Mccomb

@Mccomb 3266 is the number of days since 1-1-2000, 92689 is the amount of two second intervals from midnight. – Mccarver

@JustinKrejcha And yet there are only 86400 seconds in 24 hours... <twilight zone music> – Dogface

@Dogface two-second-intervals. Max would be 43199 at 23:59:59. The Year 3266 would be something in 2008. I guess that Sam chose some random numbers. – Leap

Excellent! This was so useful to me that I blogged it: pretty much the same instructions as above but with some screenshots to demonstrate: technical-recipes.com/2018/… – Here

does this no longer work in vs2022? for me.. when i compile my project.. the assemblyinfo.cs file doesn't get updated.. – Wickiup

Unfortunately, this no longer works for VS2022 and .NET 7 – Sherer

Answer 2

open up the AssemblyInfo.cs file and change

// You can specify all the values or you can default the Build and Revision Numbers 
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

to

[assembly: AssemblyVersion("1.0.*")]
//[assembly: AssemblyFileVersion("1.0.0.0")]

you can do this in IDE by going to project -> properties -> assembly information

This however will only allow you to auto increment the Assembly version and will give you the

Assembly File Version: A wildcard ("*") is not allowed in this field

message box if you try place a * in the file version field.

So just open up the assemblyinfo.cs and do it manually.

Boggers

Yes I just encountered the ""Assembly File Version: A wildcard ("*") is not allowed in this field" that's what won your method the green tick :D – Mongrelize

@in.spite - thats odd i have VS2005 pro and it seems to work the same as vs 2008. – Boggers

this works: [assembly: AssemblyVersion("1.0.*")] //[assembly: AssemblyFileVersion("1.0.0.0")] – Mongrelize

You need to do it in the AssemblyInfo.cs file as discussed. Unfortunately the "Assembly Information" dialog throws an error for our "benefit". Discussion here: connect.microsoft.com/VisualStudio/feedback/… – Acquiesce

Also, within the Assembly Information IDE, make sure you either blank out anything smaller than the * in your Assembly version. It tells you you have an "invalid version format" if you don't (e.g., 0 1 * 0 => fail). – Kalimantan

It is not desirable to change the AssemblyVersion number during a release cycle. Instead, the AssemblyFileVersion should be changed. See my blog post on this topic: philippetruche.wordpress.com/2008/08/12/… Also see Suzanne Cook's excellent post on when to change the numbers: blogs.msdn.com/b/suzcook/archive/2003/05/29/57148.aspx – Ornamentation

I'd be careful using the * it will stop working on June 4th 2179 when the day becomes 65536 – Shf

How can this be achieved in the new csproj format where there is no AssemblyInfo.cs? – Erastatus

@Shimmy: Add <Deterministic>False</Deterministic> to .csproj Auto Versioning in Visual Studio 2017 (.NET Core) – Disaffirm

@LloydPowell: MS Excel tells me "June 6th", so at your date you have 2 days left to find a workaround ;-) And don't forget to tell your grandchildren about that issue. – Fusco

@Lloyd Powell, you made my day :D +1 ! – Pinette

@ChrisW I'm glad my 'banter' from 11 years ago is still providing entertainment for the .net community :-) – Shf

@LloydPowell Yeah, it's kinda timeless. Almost :D – Pinette

Answer 3

Another option for changing version numbers in each build is to use the Version task of MSBuild.Community.Tasks. Just download their installer, install it, then adapt the following code and paste it after <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> in your .csproj file:

<Import Project="$(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.Targets" />
<Target Name="BeforeBuild">
    <Version VersionFile="Properties\version.txt" Major="1" Minor="0" BuildType="Automatic" StartDate="12/31/2009" RevisionType="BuildIncrement">
      <Output TaskParameter="Major" PropertyName="Major" />
      <Output TaskParameter="Minor" PropertyName="Minor" />
      <Output TaskParameter="Build" PropertyName="Build" />
      <Output TaskParameter="Revision" PropertyName="Revision" />
    </Version>
    <AssemblyInfo CodeLanguage="CS"
                  OutputFile="Properties\VersionInfo.cs"
                  AssemblyVersion="$(Major).$(Minor)"
                  AssemblyFileVersion="$(Major).$(Minor).$(Build).$(Revision)" />
</Target>

Note: Adapt the StartDate property to your locale. It currently does not use the invariant culture.

For the third build on January 14th, 2010, this creates a VersionInfo.cs with this content:

[assembly: AssemblyVersion("1.0")]
[assembly: AssemblyFileVersion("1.0.14.2")]

This file then has to be added to the project (via Add existing item), and the AssemblyVersion and AssemblyFileVersion lines have to be removed from AssemblyInfo.cs.

The different algorithms for changing the version components are described in $(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.chm and Version Properties.

Atherosclerosis

This is the best way yet that I've seen to get around the awful fact that FileVersion structs use 16 bit integers. – Workmanlike

I had issues installing into VS2012 using the Package Console so recommend using the downloaded nightly msi installers at github.com/loresoft/msbuildtasks/downloads. Works copy/paste from the above. Thanks! – Pappose

After it was denied and edit on this post: "You may also want to check this loresoft.com/projects/msbuildtasks/… it can improve the basic functionality described before." – Moonfaced

This is not a viable solution for those who build with TFS. Ultimatey, this will add a pending edit to the VersionInfo.cs and version.txt files. For me, it is not desirable to have a pending edit for each build. – Glassworker

@Glassworker see here for TFS versioning tips... – Atherosclerosis

Answer 4

I came up with a solution similar to Christians but without depending on the Community MSBuild tasks, this is not an option for me as I do not want to install these tasks for all of our developers.

I am generating code and compiling to an Assembly and want to auto-increment version numbers. However, I can not use the VS 6.0.* AssemblyVersion trick as it auto-increments build numbers each day and breaks compatibility with Assemblies that use an older build number. Instead, I want to have a hard-coded AssemblyVersion but an auto-incrementing AssemblyFileVersion. I've accomplished this by specifying AssemblyVersion in the AssemblyInfo.cs and generating a VersionInfo.cs in MSBuild like this,

  <PropertyGroup>
    <Year>$([System.DateTime]::Now.ToString("yy"))</Year>
    <Month>$([System.DateTime]::Now.ToString("MM"))</Month>
    <Date>$([System.DateTime]::Now.ToString("dd"))</Date>
    <Time>$([System.DateTime]::Now.ToString("HHmm"))</Time>
    <AssemblyFileVersionAttribute>[assembly:System.Reflection.AssemblyFileVersion("$(Year).$(Month).$(Date).$(Time)")]</AssemblyFileVersionAttribute>
  </PropertyGroup>
  <Target Name="BeforeBuild">
    <WriteLinesToFile File="Properties\VersionInfo.cs" Lines="$(AssemblyFileVersionAttribute)" Overwrite="true">
    </WriteLinesToFile>
  </Target>

This will generate a VersionInfo.cs file with an Assembly attribute for AssemblyFileVersion where the version follows the schema of YY.MM.DD.TTTT with the build date. You must include this file in your project and build with it.

Warrant

Does MSBuild support variables? It would be better to put [System.DateTime]::Now into one, otherwise, there's a race condition that can cause an old build number to be used if building near midnight. – Irreformable

Did you define these four properties instead of combining them in a single DateTime.ToString for demonstrative purposes, or is there a particular reason? – Sciuroid

If your BeforeBuild event doesn't fire in VS2017 check out #43922492 – Buckley

This solution is the best fit out of all the answers here. However, the problem is, the timestamp (or the content of the versioninfo.cs file) does not update if you build the project for the second time which should produce a different minute. If I close and reload the project, then the timestamp gets updated. Is this a bug from MSBuild? @Warrant – Elohim

Is this possible to make any operation in these markups? With $([System.DateTime]::Today.Year - 2010), I get an error unable to evaluate expression ""24/08/2020 00:00:00".Year - 2010". Cannot find method 'SystemDateTime.Year -2009'. – Tehuantepec

That's an excellent solution for someone who wants to follow calver! +1 from me. One thing I would simplify is the variables: <Date>$([System.DateTime]::Now.ToString("yyyy.M.d.HHmm"))</Date>. Works like a charm. – Lundin

Answer 5

There is a visual studio extension Automatic Versions which supports Visual Studio (2017,2019 & 2022)

Screen Shots

Carbuncle

So I have uninstalled it and I can say even more... it modifies original csproj file. I think it is very problematic extension. – Company

@Company Try latest version, it should work on VS 2017 – Byler

Excellent util. Works fine for me in vs2017. Docs could be slightly clearer, but install it (via the site) and then install MSBuild via Nuget, apply to a small project and play and build. Nice. @Boog's answer didn't work for me although he said exactly what I was trying to achieve. – Branny

Yes! I love this product!! – Helvellyn

VS2022 supported! – Indefinite

Answer 6

Install the Build Version Increment add-in. It gives you way more control than the * option.

Tribadism

Only for VS2005/2008, with a beta for VS2010 – Intensity

autobuildversion.codeplex.com/discussions/393154 The DropBox link near the end of the thread, from r3mote203, is for 2010 and works in 2012 (and maybe 2013). – Apprise

I'm using Automatic Versions for VS2012, and it's working very well. – Disremember

Answer 7

To get the version numbers try

 System.Reflection.Assembly assembly = System.Reflection.Assembly.GetExecutingAssembly();
 System.Reflection.AssemblyName assemblyName = assembly.GetName();
 Version version = assemblyName.Version;

To set the version number, create/edit AssemblyInfo.cs

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

Also as a side note, the third number is the number of days since 2/1/2000 and the fourth number is half of the amount of total seconds in the day. So if you compile at midnight it should be zero.

Kendre

Answer 8

In Visual Studio 2019

It was not enough for me adding

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

When building it throws me this error

The specified version string does not conform to the required format

Solution

The format was finally accepted after I set Deterministic to False in project.csproj

<Deterministic>false</Deterministic>

---

Edit:

For some reason setting Deterministic to False messed up my config file loading it and saving it on different locations.

Workaround:

I setup a post-build event to increment the revision number:

Post-Build Event batch script

This calls a powershell script named autoincrement_version.ps1 passing as argument the path of AssemblyInfo.cs

if $(ConfigurationName) == Release (
PowerShell -ExecutionPolicy RemoteSigned $(ProjectDir)autoincrement_version.ps1 '$(ProjectDir)My Project\AssemblyInfo.cs'
)

Poweshell script

It autoincrements the revision number using Regex

param( [string]$file );
  $regex_revision = '(?<=Version\("(?:\d+\.)+)(\d+)(?="\))'
  $found = (Get-Content $file) | Select-String -Pattern $regex_revision
  $revision = $found.matches[0].value
  $new_revision = [int]$revision + 1
  (Get-Content $file) -replace $regex_revision, $new_revision | Set-Content $file -Encoding UTF8

Vaughn

Answer 9

Setting a * in the version number in AssemblyInfo or under project properties as described in the other posts does not work with all versions of Visual Studio / .NET.

Afaik it did not work in VS 2005 (but in VS 2003 and VS 2008). For VS 2005 you could use the following: Auto Increment Visual Studio 2005 version build and revision number on compile time.

But be aware that changing the version number automatically is not recommended for strong-named assemblies. The reason is that all references to such an assembly must be updated each time the referenced assembly is rebuilt due to the fact that strong-named assembly references are always a reference to a specific assembly version. Microsoft themselves change the version number of the .NET Framework assemblies only if there are changes in interfaces. (NB: I'm still searching for the link in MSDN where I read that.)

Raynor

I think for any version of VS you can only put the * in the Build or Revision boxes. I just tried this out using VS 2005, and it works fine. I'm not sure what the author of that code project article is talking about. – Straw

Maybe it came back with a service pack, but I remember that it did not use to work when I was using VS 2005. – Raynor

It does not work with 2005, I'll look for a service pack and report back. – Mongrelize

Maybe MusiGenesis has an add-on installed which is enabling automatic versioning. – Raynor

@divo: no, I'm add-on-phobic. I just have Visual Studio 2005 Professional SP1. I've never seen a problem with the *, but I usually increment manually. Sounds like a weird bug. – Straw

@0xA3 I believe the MSDN link you are referring to is support.microsoft.com/kb/556041 – Tramontane

Answer 10

To get incrementing (DateTime) information into the AssemblyFileVersion property which has the advantage of not breaking any dependencies.

---

Building on Boog's solution (did not work for me, maybe because of VS2008?), you can use a combination of a pre-build event generating a file, adding that file (including its version properties) and then using a way to read out those values again. That is..

Pre-Build-Event:

echo [assembly:System.Reflection.AssemblyFileVersion("%date:~-4,4%.%date:~-7,2%%date:~-10,2%.%time:~0,2%%time:~3,2%.%time:~-5,2%")] > $(ProjectDir)Properties\VersionInfo.cs

Include the resulting VersionInfo.cs file (Properties subfolder) into your project

Code to get Date back (years down to seconds):

var version = assembly.GetName().Version;
var fileVersionString = System.Diagnostics.FileVersionInfo.GetVersionInfo(assembly.Location).FileVersion;
Version fileVersion = new Version(fileVersionString);
var buildDateTime = new DateTime(fileVersion.Major, fileVersion.Minor/100, fileVersion.Minor%100, fileVersion.Build/100, fileVersion.Build%100, fileVersion.Revision);

Not very comfortable.. also, I do not know if it creates a lot of force-rebuilds (since a file always changes).

You could make it smarter for example if you only update the VersionInfo.cs file every few minutes/hours (by using a temporary file and then copying/overwriting the real VersionInfo.cs if a change large enough is detected). I did this once pretty successfully.

Dimaggio

It works perfectly. However, this regular expression %date:~-4,4%.%date:~-7,2%%date:~-10,2%.%time:~0,2%%time:~3,2%.%time:~-5,2%" is just too complicated. – Elohim

Answer 11

How to get the version {major}.{year}.1{date}.1{time}

This one is kind of experimental, but I like it. Inspired by Jeff Atwood @ CodingHorror (link).

The resulting version number becomes 1.2016.10709.11641 (meaning 2016-07-09 16:41), which allows for

• poor mans zero padding (with the stupid leading 1s)
• nearly-human readable local DateTime embedded into the version number
• leaving Major version alone for really major breaking changes.

Add a new item to your project, select General -> Text Template, name it something like CustomVersionNumber and (where applicable) comment out the AssemblyVersion and AssemblyFileVersion in Properties/AssemblyInfo.cs.

Then, when saving this file, or building the project, this will regenerate a .cs file located as a sub-item under the created .tt file.

<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>

//
// This code was generated by a tool. Any changes made manually will be lost
// the next time this code is regenerated.
//

using System.Reflection;

<#
    var date = DateTime.Now;
    int major = 1;
    int minor = date.Year;
    int build = 10000 + int.Parse(date.ToString("MMdd"));
    int revision = 10000 + int.Parse(date.ToString("HHmm"));
#>

[assembly: AssemblyVersion("<#= $"{major}.{minor}.{build}.{revision}" #>")]
[assembly: AssemblyFileVersion("<#= $"{major}.{minor}.{build}.{revision}" #>")]

Spermine

You are not compiling your program every minute or deploying more than once a day, so technically the time part is unnecessarily occupying valuable information, I would use 1st and 2nd for major minor and and just use 3rd number for date yyddd (two digit year + ddd day from start of same year) and leave 4th for incremental build number. – Wilful

Answer 12

Set the version number to "1.0.*" and it will automatically fill in the last two number with the date (in days from some point) and the time (half the seconds from midnight)

Dvandva

hey if I had read this properly at the beginning I would have saved myself mucho agro. thx – Mongrelize

Answer 13

It is in your project properties under Publish

(~ http://screencast.com/t/Vj7rhqJO)

Miriam

Answer 14

Cake supports AssemblyInfo files patching. With cake in hands you have infinite ways to implement automatic version incrementing.

Simple example of incrementing version like C# compiler does:

Setup(() =>
{
    // Executed BEFORE the first task.
    var datetimeNow = DateTime.Now;
    var daysPart = (datetimeNow - new DateTime(2000, 1, 1)).Days;
    var secondsPart = (long)datetimeNow.TimeOfDay.TotalSeconds/2;
    var assemblyInfo = new AssemblyInfoSettings
    {
        Version = "3.0.0.0",
        FileVersion = string.Format("3.0.{0}.{1}", daysPart, secondsPart)
    };
    CreateAssemblyInfo("MyProject/Properties/AssemblyInfo.cs", assemblyInfo);
});

Here:

• Version - is assembly version. Best practice is to lock major version number and leave remaining with zeroes (like "1.0.0.0").
• FileVersion - is assembly file version.

Note that you can patch not only versions but also all other necessary information.

Circuity

Answer 15

Go to Project | Properties and then Assembly Information and then Assembly Version and put an * in the last or the second-to-last box (you can't auto-increment the Major or Minor components).

Straw

Answer 16

As of right now, for my application,

string ver = Application.ProductVersion;

returns ver = 1.0.3251.27860

The value 3251 is the number of days since 1/1/2000. I use it to put a version creation date on the splash screen of my application. When dealing with a user, I can ask the creation date which is easier to communicate than some long number.

(I'm a one-man dept supporting a small company. This approach may not work for you.)

Anatollo

Your number is gonna run out fast. I would use yyddd which is 2 digit year and 3 digit day from start of year which is max 365. at least your program would compile until year 2065. then you would be retired and let someone else figure out how they want to handle it. given your program is still in commission at that date! – Wilful

Answer 17

Use the AssemblyInfo task from the MSBuild Community Tasks (http://msbuildtasks.tigris.org/) project, and integrate it into your .csproj/.vbproj file.

It has a number of options, including one to tie the version number to the date and time of day.

Recommended.

Mistake

Answer 18

Maybe, for this task, you can use code like this:

    private bool IncreaseFileVersionBuild()
    {
        if (System.Diagnostics.Debugger.IsAttached)
        {
            try
            {
                var fi = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory).Parent.Parent.GetDirectories("Properties")[0].GetFiles("AssemblyInfo.cs")[0];
                var ve = System.Diagnostics.FileVersionInfo.GetVersionInfo(System.Reflection.Assembly.GetExecutingAssembly().Location);
                string ol = ve.FileMajorPart.ToString() + "." + ve.FileMinorPart.ToString() + "." + ve.FileBuildPart.ToString() + "." + ve.FilePrivatePart.ToString();
                string ne = ve.FileMajorPart.ToString() + "." + ve.FileMinorPart.ToString() + "." + (ve.FileBuildPart + 1).ToString() + "." + ve.FilePrivatePart.ToString();
                System.IO.File.WriteAllText(fi.FullName, System.IO.File.ReadAllText(fi.FullName).Replace("[assembly: AssemblyFileVersion(\"" + ol + "\")]", "[assembly: AssemblyFileVersion(\"" + ne + "\")]"));
                return true;
            }
            catch
            {
                return false;
            }
        }
        return false;
    }

and call it from form loading.
With this code you can update any part of file info in AssemblyInfo.cs (but you must use "standard" directory structure).

Coenurus

Answer 19

Changing the AssemblyInfo works in VS2012. It seems strange that there's not more support for this in Visual Studio, you'd think this was a basic part of the build/release process.

Prattle

Answer 20

I have created an application to increment the file version automatically.

1. Download Application

2. add the following line to pre-build event command line

   C:\temp\IncrementFileVersion.exe $(SolutionDir)\Properties\AssemblyInfo.cs

3. Build the project

To keep it simple the app only throws messages if there is an error, to confirm it worked fine you will need to check the file version in 'Assembly Information'

Note : You will have to reload the solution in Visual studio for 'Assembly Information' button to populate the fields, however your output file will have the updated version.

For suggestions and requests please email me at [email protected]

Worthless

Answer 21

AssemblyInfoUtil. Free. Open-source.

Khiva

Answer 22

I'm using this approach https://mcmap.net/q/73528/-how-to-have-an-auto-incrementing-version-number-visual-studio-duplicate by placing the T4 template in a "Solution Items" and using it with "Add as Link" within each project.

Adlee

Answer 23

Maybe it's too late to answer here but hope that will solve someone's hectic problem.

An automatic way to change assembly version of all of your projects using PowerShell script. This article will solve many of your problems.

Bertiebertila

The only problem with PS is it is slow to react and requires configuration to allow it to run. I would go with a small executable, a tt4 file or even inline code which I think any programmer can write in one way. – Wilful

Answer 24

I tried this with Visual Studio 2019 and it did not work. In newer versions of VS at least the Deterministic-flag prevents the auto-update. But changing the 14th line of Your-project-name.csproj to <Deterministic>false</Deterministic> and changing the version number string to "1.0.*" did not help me.

So I made a litle vbs script that does the job. it changes the version number to (Major version).(Minor version).([year][dayofyear]).(increment).

Copy the script into a folder and put the following into pre-compile build-commandline:

"Path-to-this-script\UpdateVersion.vbs"  "$(ProjectDir)"

(including the quotes and filling in the real path of Your machine) and You are done.

Get it here: https://github.com/abtzero/VS_UpdateVersion.git

Counterpane

Answer 25

Each time I do a build it auto-increments the least-significant digit.

I don't have any idea how to update the others, but you should at least be seeing that already...

Illegal

The VS is in charge of incrementing the last number which is usually the build number. Everything else (i.e. the numbers before that) is up to you because they represent the version of your application. – Sequela

Огњен Шобајић: Not quite right. Microsoft's numbering scheme is major.minor.build.revision, eg 1.0.4.7. If you set the assembly version to something like "1.0.*" then VS will set the build and revision numbers for you. In that case build will increment daily, and revision will be the number of seconds since midnight, divided by 2. – Samoyedic

Answer 26

For anyone using Tortoise Subversion, you can tie one of your version numbers to the subversion Revision number of your source code. I find this very useful (Auditors really like this too!). You do this by calling the WCREV utility in your pre-build and generating your AssemblyInfo.cs from a template.

If your template is called AssemblyInfo.wcrev and sits in the normal AssemblyInfo.cs directory, and tortoise is in the default installation directory, then your Pre-Build command looks like this (N.B. All on one line):

"C:\Program Files\TortoiseSVN\bin\SubWCRev.exe" "$(ProjectDir)." "$(ProjectDir)Properties\AssemblyInfo.wcrev"  "$(ProjectDir)Properties\AssemblyInfo.cs"

The template file would include the wcrev token substitution string: $WCREV$
e.g.

[assembly: AssemblyFileVersion("1.0.0.$WCREV$")]

Note:
As your AssemblyInfo.cs is now generated you do not want it version controled.

Stigmatize

Answer 27

If you are using Git + TortoiseGit there are very easy way to update AssemblyInfo.cs and update values of AssemblyVersion and AssemblyFileVersion with number of git commits count.

1. Copy your AssemblyInfo.cs and name it AssemblyInfo.template
2. Comment out lines below in AssemblyInfo.cs:

//[assembly: AssemblyVersion("1.0.*")]
//[assembly: AssemblyFileVersion("1.0.*")]</pre>

3. Change these lines in your AssemblyInfo.template file as:

[assembly: AssemblyVersion("1.0.1.$WCLOGCOUNT$")]
[assembly: AssemblyFileVersion("1.0.1.$WCLOGCOUNT$")]

4. Add this line to your project's prebiuld events:

GitWCRev "$(ProjectDir)\" "$(ProjectDir)Properties\AssemblyInfo.template" "$(ProjectDir)Properties\AssemblyInfo.cs"

Now, (even if you are building on Debug Configuration) your AssemblyInfo.cs will be generated like this:

[assembly: AssemblyVersion("1.0.1.444")]
[assembly: AssemblyFileVersion("1.0.1.444")]

And you are ready.

Isomeric