Posso automaticamente incrementar a versão de compilação do arquivo quando usando o Visual Studio?

https://stackoverflow.com/questions/356543

21-08-2019
|

Pergunta

Eu estava pensando como eu poderia automaticamente incrementar a construção (e versão?) Dos meus arquivos usando o Visual Studio (2005).

Se eu olhar para cima as propriedades de C:\Windows\notepad.exe digamos, na guia versão dá "versão do arquivo: 5.1.2600.2180". Eu gostaria de obter esses números fresco na versão do meu dll é muito, não a versão 1.0.0.0, que vamos enfrentá-lo é um pouco aborrecido.

Eu tentei algumas coisas, mas não parece ser a funcionalidade out-of-box, ou talvez eu estou apenas procurando no lugar errado (como sempre).

Eu trabalho principalmente com projetos web ....

Eu olhei para ambos:

e eu não podia acreditar tanto esforço para fazer algo é uma prática padrão.

EDIT: Não funciona em VS2005 tão longe eu posso dizer ( http: // www. codeproject.com/KB/dotnet/AutoIncrementVersion.aspx )

Solução

No Visual Studio 2008, os seguintes trabalhos.

Encontre o arquivo AssemblyInfo.cs e encontrar estas 2 linhas:

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

Você pode tentar mudar isso para:

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

Mas isso não vai lhe dar o resultado desejado, você vai acabar com uma versão do produto de 1.0. * e uma versão do arquivo de 1.0.0.0 . Não é o que você quer!

No entanto, se você remover a segunda dessas linhas e apenas se:

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

Em seguida, o compilador irá definir a versão do arquivo a ser igual à versão do produto e você vai obter o resultado desejado de uma versão do produto e arquivo automaticamente incremento que estão em sincronia. Por exemplo. 1.0.3266.92689

Outras dicas

abrir o arquivo AssemblyInfo.cs e mudança

// 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")]

para

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

Você pode fazer isso no IDE, indo para projeto -> Propriedades -> informações de assembly

Este, porém, só irá permitir que você a auto incremento a versão de montagem e lhe dará a

Assembleia de arquivo Versão: Um wildcard ( "*") não é permitido neste campo

caixa de mensagem se você tentar colocar um * no campo de versão do arquivo.

Então, basta abrir as assemblyinfo.cs e fazê-lo manualmente.

Outra opção para alterar os números de versão em cada construção é usar a tarefa Versão de MSBuild .Community.Tasks . Basta baixar o instalador, instale-o, em seguida, adaptar o seguinte código e colá-lo após <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> em seu arquivo .csproj:

<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>

Nota: Adaptar a propriedade StartDate à sua localidade. Atualmente, não usa a cultura invariável.

Para a terceira construção em 14 de janeiro de 2010, isso cria um VersionInfo.cs com este conteúdo:

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

Este arquivo, em seguida, tem de ser adicionado ao projeto (via Adicionar item existente ), e as linhas AssemblyVersion e AssemblyFileVersion têm de ser removidos do AssemblyInfo.cs.

Os algoritmos diferentes para alterar os componentes da versão são descritos em $(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.chm e Propriedades Versão .

Eu vim com uma solução semelhante para os cristãos, mas sem dependendo das tarefas da Comunidade do MSBuild, esta não é uma opção para mim como eu não deseja instalar essas tarefas para todos os nossos desenvolvedores.

Eu estou gerando código e compilar a um Assembly e quer números de versão de auto-incremento. No entanto, eu não posso usar o VS 6.0. * Truque AssemblyVersion como it-incrementos auto números de compilação cada compatibilidade dia e breaks com as Assembléias que usam um número de compilação mais velho. Em vez disso, eu quero ter um AssemblyVersion hard-coded, mas uma AssemblyFileVersion auto-incremento. Eu tenho feito isso especificando AssemblyVersion nas AssemblyInfo.cs e gerando um VersionInfo.cs em MSBuild como esta,

  <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>

Isso irá gerar um arquivo VersionInfo.cs com um atributo Assembly para AssemblyFileVersion onde a versão segue o esquema de YY.MM.DD.TTTT com a data de criação. Você deve incluir esse arquivo no seu projeto e construir com ele.

Instale o Desenvolver Versão Incremento add-in. Dá-lhe muito mais controle do que a opção *.

Para obter os números de versão tente

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

Para definir o número da versão, criar / editar AssemblyInfo.cs

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

Além disso, como uma nota lado, o terceiro número é o número de dias desde 2000/02/01 e o quarto número é a metade da quantidade de total de segundos no dia. Então, se você compilar à meia-noite que deveria ser zero.

Não é uma extensão do visual studio versões automáticas que suporta Visual Studio 2012, 2013, 2015 e 2017.

Shots Tela

A definição de um * no número da versão em AssemblyInfo ou sob propriedades do projeto, conforme descrito nas outras mensagens não funciona com todas as versões do Visual Studio / .NET.

AFAIK não funcionou no VS 2005 (mas em VS 2003 e VS 2008). Para VS 2005 você poderia usar o seguinte: Auto Incremento Visual Studio 2005 versão de compilação e revisão número de compilação tempo .

Mas esteja ciente de que a mudança do número da versão automática não é recomendada para montagens de nome forte. A razão é que todas as referências a esse conjunto deve ser atualizado cada vez que o referenciada montagem é reconstruída devido ao fato de que as referências de nome forte assembly são sempre uma referência a uma versão de montagem específica. Microsoft-se alterar o número da versão dos assemblies do .NET Framework somente se houver alterações em interfaces. (NB:. Eu ainda estou procurando o link no MSDN onde eu li isso)

Para obter incremento (DateTime) informações para a propriedade AssemblyFileVersion que tem a vantagem de não quebrar quaisquer dependências.

Com base na solução de Boog (não funcionou para mim, talvez por causa da VS2008?), Você pode usar uma combinação de um evento de pré-compilação gerando um arquivo, acrescentando que arquivo (incluindo suas propriedades de versão) e, em seguida, usando uma forma para ler esses valores novamente. Isso é ..

Pre-Build-Evento:

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

Inclua o arquivo VersionInfo.cs resultante (Propriedades subpasta) em seu projeto

código para obter remontam (anos até segundos):

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);

Não é muito confortável .. também, eu não sei se ele cria um monte de força-reconstruções (desde que um ficheiro sempre muda).

Você poderia torná-lo mais inteligente, por exemplo, se você só atualizar o arquivo VersionInfo.cs cada POUCOS MINUTOS / horas (usando um arquivo temporário e, em seguida, copiar / substituir os VersionInfo.cs reais se um grande o suficiente alteração é detectada). Eu fiz isso uma vez muito sucesso.

Defina o número de versão para "1.0. *" E que irá preencher automaticamente os dois último número com a data (em dias de algum ponto) eo tempo (metade dos segundos a partir da meia-noite)

Está em suas propriedades do projeto em Publicar

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

bolo AssemblyInfo arquivos remendar. Com o bolo nas mãos você tem infinitas maneiras de implementar incremento versão automática.

Um exemplo simples de incrementar versão como compilador C # faz:

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);
});

Aqui:

Version - é a montagem da versão. A melhor prática é para bloquear número de versão principal e deixar restante com zeros (como "1.0.0.0").
FileVersion -. É a montagem da versão do arquivo

Note que você pode corrigir não só as versões, mas também todas as outras informações necessárias .

Go to Project | Propriedades e, em seguida, informações de assembly e, em seguida, Versão montagem e colocar um * no último ou o segundo-a-última caixa (você não pode auto-incremento das maiores ou menores componentes).

Use a tarefa AssemblyInfo das tarefas MSBuild Comunidade ( http://msbuildtasks.tigris.org/ ) projeto e integrá-lo em seu .csproj / arquivo .vbproj.

Ele tem uma série de opções, incluindo um para amarrar o número da versão para a data e hora do dia.

Recomendado.

A partir de agora, para a minha candidatura,

string ver = Application.ProductVersion;

retornos ver = 1.0.3251.27860

O valor 3251 é o número de dias desde 1/1/2000. Eu usá-lo para colocar uma data de criação da versão na tela inicial do meu pedido. Ao lidar com um usuário, posso perguntar a data de criação que é mais fácil de se comunicar de algum número longo.

(eu sou um dept de um homem só apoiar uma pequena empresa. Esta abordagem pode não funcionar para você.)

A alteração do AssemblyInfo funciona em VS2012. Parece estranho que não há mais suporte para isso no Visual Studio, você pensaria que isso era uma parte fundamental do processo de construção / release.

Como obter a versão `{major}.{year}.1{date}.1{time}`

Este é o tipo de experimental, mas eu gosto. Inspirado por Jeff Atwood @ CodingHorror ( ligação ).

O número de versão resultante torna-se 1.2016.10709.11641 (significando 2016/07/09 16:41), o que permite

mans pobres zerar preenchimento (com as 1s líderes estúpidos)
quase-humano legível Local DateTime embutido no número da versão
deixando versão major sozinho para realmente grandes alterações significativas.

Adicionar um novo item ao seu projeto, selecione Geral -> modelo de texto, nomeie-o algo como CustomVersionNumber e (quando aplicável) comentário a AssemblyVersion e AssemblyFileVersion em Properties/AssemblyInfo.cs

Então, ao salvar esse arquivo, ou construir o projeto, isso vai regenerar um arquivo .cs localizado como um sub-item sob o arquivo .tt criado.

<#@ 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}" #>")]

Talvez, para esta tarefa, você pode usar um código como este:

    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;
    }

e chamá-lo de forma carregamento.
Com este código você pode atualizar qualquer parte de arquivo de informações em AssemblyInfo.cs (mas você deve usar o "padrão" estrutura de diretórios).

AssemblyInfoUtil . Livre. Open-source.

Eu estou usando esta abordagem https://stackoverflow.com/a/827209/3975786 colocando o T4 template em um "Solution Items" e usá-lo com "Adicionar como link" dentro de cada projeto.

Talvez seja tarde demais para responder aqui, mas a esperança de que vai resolver o problema agitado de alguém.

Um forma automática para alterar a versão de montagem de todos os seus projetos usando script do PowerShell. vontade Este artigo resolver muitos dos seus problemas.

Cada vez que eu faço uma compilação-lo auto-incrementos o dígito menos significativo.

Eu não tenho nenhuma idéia de como atualizar os outros, mas você deve pelo menos estar vendo que já ...

Eu criei uma aplicação para incrementar a versão do arquivo automaticamente.

Aplicação
adicione a seguinte linha de pré-build linha de comando evento

C: \ temp \ IncrementFileVersion.exe $ (SolutionDir) \ Propriedades \ AssemblyInfo.cs
Crie o projeto

Para mantê-lo simples, o aplicativo só joga mensagens se houver um erro, para confirmar que funcionou bem você terá que verificar a versão do arquivo em 'Informações de montagem'

Nota:. Você vai ter que recarregar a solução no Visual Studio para o botão 'Informações de montagem' para preencher os campos, no entanto o seu arquivo de saída terá a versão atualizada

Para sugestões e pedidos por favor me escreva em telson_alva@yahoo.com

No Visual Studio 2019

Não foi o suficiente para me adicionando

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

Ao construir isto me lança este erro

A cadeia de versão especificado não é compatível com o formato exigido

Solução

O formato foi finalmente aceite depois de eu set Deterministic para False em project.csproj

<Deterministic>false</Deterministic>

Editar:

Para alguns configuração razão Deterministic para False errei meu arquivo de configuração de carregamento-lo e salvá-lo em locais diferentes.

Solução alternativa:

Configuração I um evento pós-compilação para incrementar o número de revisão:

Pós-script de construção lote Evento

Esta chama um script PowerShell chamado autoincrement_version.ps1 passando como argumento o caminho da AssemblyInfo.cs

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

Poweshell roteiro

É autoincrements o número de revisão usando 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

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow

Posso automaticamente incrementar a versão de compilação do arquivo quando usando o Visual Studio?

Como obter a versão {major}.{year}.1{date}.1{time}

No Visual Studio 2019

Solução

Editar:

Solução alternativa:

Pós-script de construção lote Evento

Poweshell roteiro

Como obter a versão `{major}.{year}.1{date}.1{time}`