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

Se eu procurar as propriedades do say C:\Windows\notepad.exe, a guia Versão exibirá "Versão do arquivo: 5.1.2600.2180". Gostaria de obter esses números interessantes também na versão das minhas DLLs, não na versão 1.0.0.0, o que vamos encarar é um pouco chato.

Eu tentei algumas coisas, mas não parece ser uma funcionalidade pronta para uso, ou talvez eu esteja apenas procurando no lugar errado (como de costume).

Trabalho principalmente com projetos web ....

Eu olhei para os dois:

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

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

Edição: ele não funciona no VS2005, tanto quanto eu posso dizer ( http://www.codeproject.com/KB/dotnet/AutoIncrementVersion.aspx )

No visual Studio 2008, o seguinte funciona.

Localize o arquivo AssemblyInfo.cs e encontre 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 fornecerá o resultado desejado, você terminará com uma versão do produto 1.0. * E uma versão do arquivo 1.0.0.0 . Não é o que você quer!

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

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

Em seguida, o compilador definirá a versão do arquivo como igual à versão do produto e você obterá o resultado desejado de um produto e versão de arquivo incrementados automaticamente que estejam sincronizados. Por exemplo 1.0.3266.92689

abra o arquivo AssemblyInfo.cs e altere

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

Isso, no entanto, permitirá apenas incrementar automaticamente a versão do Assembly e fornecerá a você

Versão do arquivo de montagem: um curinga ("*") não é permitido neste campo

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

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

Outra opção para alterar os números de versão em cada compilação é usar a tarefa Versão do MSBuild.Community.Tasks . Basta baixar o instalador, instalar, adaptar o código a seguir e colá-lo <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />no .csprojarquivo:

<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: Adapte a propriedade StartDate ao seu código do idioma. Atualmente, ele não usa a cultura invariável.

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

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

Esse arquivo deve ser adicionado ao projeto (via Adicionar item existente ), e as linhas AssemblyVersione AssemblyFileVersiondevem ser removidas AssemblyInfo.cs.

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

Eu vim com uma solução semelhante aos cristãos, mas sem depender das tarefas da Comunidade MSBuild, essa não é uma opção para mim, pois não quero instalar essas tarefas para todos os nossos desenvolvedores.

Estou gerando código e compilando em um assembly e quero incrementar automaticamente os números de versão. No entanto, não posso usar o truque do VS 6.0. * AssemblyVersion, pois aumenta automaticamente os números de compilação todos os dias e quebra a compatibilidade com os assemblies que usam um número de compilação mais antigo. Em vez disso, quero ter um AssemblyVersion codificado, mas um AssemblyFileVersion com incremento automático. Eu consegui isso especificando AssemblyVersion no AssemblyInfo.cs e gerando um VersionInfo.cs no MSBuild como este,

  <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 gerará um arquivo VersionInfo.cs com um atributo Assembly para AssemblyFileVersion, em que a versão segue o esquema de YY.MM.DD.TTTT com a data de compilação. Você deve incluir esse arquivo no seu projeto e construir com ele.

Instale o suplemento Build Version Increment . Dá a você muito mais controle do que a opção *.

Para obter os números das versões, 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, crie / edite AssemblyInfo.cs

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

Também como observação lateral, o terceiro número é o número de dias desde 1/2/2000 e o quarto número é metade da quantidade total de segundos no dia. Portanto, se você compilar à meia-noite, deve ser zero.

Existe uma extensão do visual studio Automatic Versions que suporta o Visual Studio (2012, 2013, 2015) 2017 e 2019.

Capturas de tela

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

Afaik, ele não funcionou no VS 2005 (mas no VS 2003 e VS 2008). Para o VS 2005, você pode usar o seguinte: Incremento automático Número da versão e versão do Visual Studio 2005 em tempo de compilação .

Mas lembre-se de que alterar o número da versão automaticamente não é recomendado para montagens de nome forte. O motivo é que todas as referências a essa montagem devem ser atualizadas sempre que a montagem referenciada é reconstruída devido ao fato de que as referências de montagem com nome forte são sempre uma referência a uma versão de montagem específica. A própria Microsoft altera o número da versão dos assemblies do .NET Framework somente se houver alterações nas interfaces. (NB: Ainda estou procurando o link no MSDN onde li isso.)

Para obter informações de incremento (DateTime) na propriedade AssemblyFileVersion, que tem a vantagem de não quebrar nenhuma dependência.

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

Evento de Pré-Construção:

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 (subpasta Propriedades) em seu projeto

Código para obter a data de volta (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, não sei se isso cria muitas reconstruções de força (já que um arquivo sempre muda).

Você pode torná-lo mais inteligente, por exemplo, se você atualizar apenas o arquivo VersionInfo.cs a cada poucos minutos / horas (usando um arquivo temporário e, em seguida, copiando / substituindo o VersionInfo.cs real se uma alteração grande o suficiente for detectada). Eu fiz isso uma vez com bastante sucesso.

Defina o número da versão como "1.0. *" E ele preencherá automaticamente os dois últimos números com a data (em dias de algum ponto) e a hora (meio segundo da meia-noite)

Está nas propriedades do seu projeto em Publicar

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

O Cake suporta o patch de arquivos AssemblyInfo. Com o bolo em mãos, você tem inúmeras maneiras de implementar o incremento automático de versão.

Exemplo simples de incrementar versão como o compilador C #:

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:

• Versão - é a versão da montagem. A melhor prática é bloquear o número da versão principal e deixar os zeros restantes (como "1.0.0.0").
• FileVersion - é a versão do arquivo de montagem.

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

Vá para Projeto | Propriedades e, em seguida, Informações da montagem e, em seguida, Versão da montagem e coloque um * na última ou na penúltima caixa (você não pode incrementar automaticamente os componentes Maior ou Menor).

Use a tarefa AssemblyInfo do projeto MSBuild Community Tasks ( http://msbuildtasks.tigris.org/ ) e integre-a ao seu arquivo .csproj / .vbproj.

Possui várias opções, incluindo uma para vincular o número da versão à data e hora do dia.

Recomendado.

A partir de agora, para minha inscrição,

string ver = Application.ProductVersion;

retorna ver = 1.0.3251.27860

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

(Eu sou um departamento individual que apoia uma pequena empresa. Essa abordagem pode não funcionar para você.)

Alterar o AssemblyInfo funciona no VS2012. Parece estranho que não haja mais suporte para isso no Visual Studio; você acha que essa é uma parte básica do processo de compilação / liberação.

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

Este é meio experimental, mas eu gosto. Inspirado por Jeff Atwood @ CodingHorror ( link ).

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

• pobre homem zero padding (com os líderes estúpidos 1)
• DateTime local legível quase humano incorporado ao número da versão
• deixando a versão principal sozinha para mudanças realmente importantes.

Adicione um novo item ao seu projeto, selecione Geral -> Modelo de Texto, nomeie-o como algo CustomVersionNumbere (onde aplicável) comente AssemblyVersione AssemblyFileVersionentre Properties/AssemblyInfo.cs.

Em seguida, ao salvar este arquivo ou criar o projeto, isso gerará novamente um .csarquivo localizado como um subitem no .ttarquivo 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}" #>")]

Eu criei um aplicativo para incrementar a versão do arquivo automaticamente.

1. Baixar aplicativo

2. adicione a seguinte linha para pré-construir a linha de comando do evento

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

3. Construa o projeto

Para simplificar, o aplicativo só lança mensagens se houver um erro. Para confirmar que funcionou bem, você precisará verificar a versão do arquivo em 'Informações da montagem'

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

Para sugestões e solicitações, envie um email para telson_alva@yahoo.com

No Visual Studio 2019

Não foi o suficiente para eu adicionar

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

Ao construí-lo lança-me este erro

A cadeia de versão especificada não está em conformidade com o formato necessário

Solução

O formato foi finalmente aceitou depois que eu jogo Deterministicpara Falseemproject.csproj

<Deterministic>false</Deterministic>

Editar:

Por algum motivo, defini-lo Deterministiccomo uma Falsebagunça no meu arquivo de configuração, carregando-o e salvando-o em diferentes locais.

Gambiarra:

Configurei um evento pós-compilação para incrementar o número da revisão:

Script em lote de evento pós-compilação

Isso chama um script do PowerShell denominado autoincrement_version.ps1passando como argumento o caminho deAssemblyInfo.cs

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

Script Poweshell

Incrementa automaticamente o número da revisão usando o 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

Talvez, para esta tarefa, você possa usar 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 chame-o de carregamento de formulário.
Com esse código, você pode atualizar qualquer parte das informações do arquivo em AssemblyInfo.cs (mas você deve usar a estrutura de diretórios "padrão").

AssemblyInfoUtil . Livre. Código aberto.

Estou usando essa abordagem https://stackoverflow.com/a/827209/3975786 colocando o modelo T4 em "Itens da solução" e usando-o com "Adicionar como link" em cada projeto.

Talvez seja tarde demais para responder aqui, mas espero que isso resolva o agitado problema de alguém.

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

Cada vez que eu faço uma compilação, ela incrementa automaticamente o dígito menos significativo.

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

Para quem usa o Tortoise Subversion, você pode vincular um de seus números de versão ao número de Revisão do seu código fonte. Acho isso muito útil (os auditores também gostam disso!). Você faz isso chamando o utilitário WCREV em sua pré-construção e gerando seu AssemblyInfo.cs a partir de um modelo.

Se o seu modelo se chama AssemblyInfo.wcrev e fica no diretório AssemblyInfo.cs normal, e o tartaruga está no diretório de instalação padrão, o comando Pré-Compilação fica assim: (NB Tudo em uma linha):

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

O arquivo de modelo incluiria a cadeia de substituição do token wcrev: $ WCREV $
eg

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

Nota:
Como seu AssemblyInfo.cs agora é gerado, você não deseja que sua versão seja controlada.