Setting the version number for .NET Core projects

You can create a Directory.Build.props file in the root/parent folder of your projects and set the version information there.

However, now you can add a new property to every project in one step by defining it in a single file called Directory.Build.props in the root folder that contains your source. When MSBuild runs, Microsoft.Common.props searches your directory structure for the Directory.Build.props file (and Microsoft.Common.targets looks for Directory.Build.targets). If it finds one, it imports the property. Directory.Build.props is a user-defined file that provides customizations to projects under a directory.

For example:

<Project>
  <PropertyGroup>
    <Version>0.0.0.0</Version>
    <FileVersion>0.0.0.0</FileVersion>
    <InformationalVersion>0.0.0.0.myversion</InformationalVersion>
  </PropertyGroup>
</Project>

Another option for setting version info when calling build or publish is to use the undocumented /p option.

dotnet command internally passes these flags to MSBuild.

Example:

dotnet publish ./MyProject.csproj /p:Version="1.2.3" /p:InformationalVersion="1.2.3-qa"

See here for more information: https://github.com/dotnet/docs/issues/7568

Not sure if this helps, but you can set version suffixes at publish time. Our versions are usually datetime driven, so that developers don't have to remember to update them.

If your json has something like "1.0-*"

"dotnet publish --version-suffix 2016.01.02" will make it "1.0-2016.01.02".

It's important to stick to "semvar" standards, or else you'll get errors. Dotnet publish will tell you.

Why not just change the value in the project.json file. Using CakeBuild you could do something like this (optimizations probably possible)

Task("Bump").Does(() => {
    var files = GetFiles(config.SrcDir + "**/project.json");
    foreach(var file in files)
    {
        Information("Processing: {0}", file);

        var path = file.ToString();
        var trg = new StringBuilder();
        var regExVersion = new System.Text.RegularExpressions.Regex("\"version\":(\\s)?\"0.0.0-\\*\",");
        using (var src = System.IO.File.OpenRead(path))
        {
            using (var reader = new StreamReader(src))
            {
                while (!reader.EndOfStream)
                {
                    var line = reader.ReadLine();
                    if(line == null)
                        continue;

                    line = regExVersion.Replace(line, string.Format("\"version\": \"{0}\",", config.SemVer));

                    trg.AppendLine(line);
                }
            }
        }

        System.IO.File.WriteAllText(path, trg.ToString());
    }
});

Then if you have e.g. a UnitTest project that takes a dependency on the project, use "*" for dependency resolution.

Also, do the bump before doing dotnet restore. My order is as follows:

Task("Default")
  .IsDependentOn("InitOutDir")
  .IsDependentOn("Bump")
  .IsDependentOn("Restore")
  .IsDependentOn("Build")
  .IsDependentOn("UnitTest");

Task("CI")
  .IsDependentOn("Default")
  .IsDependentOn("Pack");

Link to full build script: https://github.com/danielwertheim/Ensure.That/blob/3a278f05d940d9994f0fde9266c6f2c41900a884/build.cake

The actual values, e.g. the version is coming from importing a separate build.config file, in the build script:

#load "./buildconfig.cake"

var config = BuildConfig.Create(Context, BuildSystem);

The config file looks like this (taken from https://github.com/danielwertheim/Ensure.That/blob/3a278f05d940d9994f0fde9266c6f2c41900a884/buildconfig.cake):

public class BuildConfig
{
    private const string Version = "5.0.0";

    public readonly string SrcDir = "./src/";
    public readonly string OutDir = "./build/";    

    public string Target { get; private set; }
    public string Branch { get; private set; }
    public string SemVer { get; private set; }
    public string BuildProfile { get; private set; }
    public bool IsTeamCityBuild { get; private set; }

    public static BuildConfig Create(
        ICakeContext context,
        BuildSystem buildSystem)
    {
        if (context == null)
            throw new ArgumentNullException("context");

        var target = context.Argument("target", "Default");
        var branch = context.Argument("branch", string.Empty);
        var branchIsRelease = branch.ToLower() == "release";
        var buildRevision = context.Argument("buildrevision", "0");

        return new BuildConfig
        {
            Target = target,
            Branch = branch,
            SemVer = Version + (branchIsRelease ? string.Empty : "-b" + buildRevision),
            BuildProfile = context.Argument("configuration", "Release"),
            IsTeamCityBuild = buildSystem.TeamCity.IsRunningOnTeamCity
        };
    }
}

If you still want to have the Solution Level SharedVersionInfo.cs you can do it by adding these lines to your project.json file:

"buildOptions": {
  "compile": {
    "includeFiles": [
      "../../SharedVersionInfo.cs"
    ]
  }
}

Your relative path may vary, of course.