Posso incrementar automaticamente a versão de compilação do arquivo ao usar o Visual Studio?

358

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 )

Apesar
fonte
11
o caractere curinga parece funcionar apenas para AssemblyVersion, mas não para AssemblyFileVersion no VS 2005
dotnetcoder
Existem soluções para isso que funcionam em projetos C ++ no VS2005? Todas as respostas parecem redirecionar para .Net. Pergunta relacionada . Obrigado
Deanna
Nos projetos .Net Core , o incremento automático do AssemblyVersion não funciona por padrão. Você precisa adicionar <Deterministic> False </Deterministic> ao csproj. Veja
Controle de

Respostas:

434

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

Sam Meldrum
fonte
2
Isso funciona tão bem quanto qualquer outra coisa e funciona no VS2005. Eu estava esperando por algum número racional como 1.0.1.56, em vez de obter 1.0.3266.30135, mas pelo menos aumenta (embora por algum número aleatório: D)
apesar de
14
ah, eu acabei de ler: ele preencherá automaticamente os dois últimos números com a data (em dias a partir de algum ponto) e a hora (meio segundo da meia-noite)
inspite
20
Boa chamada na necessidade de remover o atributo AssemblyFileVersion para que isso funcione!
David Faivre
76
Sei que essa é uma pergunta antiga, mas queria adicionar esse comentário para outras pessoas que encontrarem o caminho para essa resposta. Se você incrementar a AssemblyVersion, qualquer projeto que use sua dll precisará ser recompilado. No entanto, se você mantiver o AssemblyVersion o mesmo e incrementar o AssemblyFileVersion por si só, poderá trocar a nova dll sem precisar recompilar o que estiver usando. Então, pergunte a si mesmo, isso é apenas uma nova compilação ou estou lançando uma nova versão?
Onefootswill 26/10/12
27
@ DD59 o 'Build' é o número de dias desde 1º de janeiro de 2000; a 'Revisão' é segundos da meia-noite dividida por 2 (não meio segundo, mas intervalos de dois segundos). Veja aqui: stackoverflow.com/a/3387167/11545
Cristian Diaconescu 04/04
154

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.

Tem
fonte
Sim, acabei de encontrar a "" Versão do arquivo de montagem: um curinga ("*") não é permitido neste campo "). Foi isso que ganhou no seu método o sinal verde: D
inspite
3
isso funciona: [assembly: AssemblyVersion ("1.0. *")] // [assembly: AssemblyFileVersion ("1.0.0.0")]
inspite
4
Não é desejável alterar o número da AssemblyVersion durante um ciclo de liberação. Em vez disso, o AssemblyFileVersion deve ser alterado. Veja minha publicação no blog sobre este tópico: philippetruche.wordpress.com/2008/08/12/… Veja também a excelente publicação de Suzanne Cook sobre quando alterar os números: blogs.msdn.com/b/suzcook/archive/2003/05/ 29 / 57148.aspx
Philippe
46
Eu teria cuidado usando o * que irá parar de funcionar em 04 junho de 2179, quando o dia se torna 65536
Lloyd Powell
3
@Shimmy: Add <determinística> false </ determinística> para .csproj Versioning Auto no Visual Studio 2017 (.NET Core)
Michael Freidgeim
53

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 .

cristão
fonte
2
Essa é a melhor maneira que eu já vi para contornar o terrível fato de que as estruturas do FileVersion usam números inteiros de 16 bits.
Mike Post
11
Eu tive problemas ao instalar o VS2012 usando o Console de Pacotes, por isso recomendo usar os instaladores msi noturnos baixados em github.com/loresoft/msbuildtasks/downloads . Obras copiar / colar acima. Obrigado!
DaveO
Depois que foi negado e editado nesta postagem: "Você também pode verificar este loresoft.com/projects/msbuildtasks/… e pode melhorar a funcionalidade básica descrita anteriormente."
Radu florescu 27/10/12
11
Esta não é uma solução viável para quem constrói com o TFS. Finalmente, isso adicionará uma edição pendente aos arquivos VersionInfo.cs e version.txt. Para mim, não é desejável ter uma edição pendente para cada build.
JDennis #
@JDennis veja aqui para obter dicas de controle de versão do TFS ...
Christian
25

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.

Boog
fonte
O MSBuild suporta variáveis? Seria melhor colocar [System.DateTime]::Nowem um, caso contrário, há uma condição de corrida que pode fazer com que um número de compilação antigo seja usado se for construído perto da meia-noite.
Edward Brey
Você definiu essas quatro propriedades em vez de combiná-las em uma única DateTime.ToStringpara fins demonstrativos ou existe um motivo específico?
27518 mafu ma
Se o seu evento BeforeBuild não disparar no VS2017, confira stackoverflow.com/questions/43921992/…
Rhys Jones
Esta solução é o melhor ajuste de todas as respostas aqui. No entanto, o problema é que o registro de data e hora (ou o conteúdo do arquivo versioninfo.cs) não é atualizado se você criar o projeto pela segunda vez, o que deve produzir um minuto diferente. Se eu fechar e recarregar o projeto, o carimbo de data e hora será atualizado. Isso é um bug do MSBuild? @Boog
Cary
12

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.

Prumo
fonte
12

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

Capturas de tela insira a descrição da imagem aqui

insira a descrição da imagem aqui

Rahul
fonte
Então eu o desinstalei e posso dizer ainda mais ... ele modifica o arquivo csproj original. Eu acho que é uma extensão muito problemática.
Maxim
2
@Maxim Experimente a versão mais recente, ele deve funcionar no VS 2017
Rady
Excellent util. Funciona bem para mim no vs2017. Os documentos podem ser um pouco mais claros, mas instale-o (pelo site) e instale o MSBuild via Nuget, aplique-se a um projeto pequeno e reproduza-o. Agradável. A resposta de @ Boog não funcionou para mim, embora ele tenha dito exatamente o que eu estava tentando alcançar.
Err1
8

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

Dirk Vollmar
fonte
Eu acho que para qualquer versão do VS você só pode colocar o * nas caixas Build ou Revisão. Eu apenas tentei isso usando o VS 2005, e funciona bem. Não tenho certeza do que o autor desse artigo de projeto de código está falando.
MusiGenesis
Talvez ele voltou com um service pack, mas lembro-me que não usar para o trabalho quando eu estava usando VS 2005
Dirk Vollmar
Não funciona com 2005, procurarei um service pack e apresentarei um relatório.
Inspite
Talvez o MusiGenesis tenha um complemento instalado, o que está permitindo o versionamento automático.
Dirk Vollmar
@divo: não, sou add-on-phobic. Eu apenas tenho o Visual Studio 2005 Professional SP1. Eu nunca vi um problema com o *, mas geralmente incremento manualmente. Soa como um inseto estranho.
MusiGenesis
6

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.

Andreas Reiff
fonte
Funciona perfeitamente. No entanto, esta expressão regular% date: ~ -4,4%.% Date: ~ -7,2 %% date: ~ -10,2%.% Time: ~ 0,2 %% time: ~ 3,2% .% time: ~ -5,2% "é muito complicado.
Cary
5

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)

James Curran
fonte
Ei, se eu tivesse lido isso corretamente no começo, teria me economizado muito. thx
inspite
4

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 .

hal
fonte
3

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

MusiGenesis
fonte
2

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.

devstuff
fonte
2

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ê.)

SeaDrive
fonte
Seu número vai acabar rapidamente. Eu usaria o yyddd, que é o ano de 2 dígitos e o dia de 3 dígitos desde o início do ano, que é no máximo 365. pelo menos o seu programa seria compilado até o ano 2065. então você seria aposentado e deixaria alguém descobrir como eles querem lidar com isso. dado que seu programa ainda está em comissão nessa data!
AaA
2

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.

Maxcelcat
fonte
2

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

fonte
Você não está compilando seu programa a cada minuto ou implantando mais de uma vez por dia; portanto, tecnicamente, a parte do tempo está ocupando desnecessariamente informações valiosas; eu usaria o 1º e o 2º para menores maiores e apenas o terceiro número para a data yyddd (ano de dois dígitos + ddd dia do início do mesmo ano) e deixe o quarto para o número de compilação incremental.
AaA
2

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 [email protected]

Telson Alva
fonte
2

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
Madacol
fonte
1

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").

Atiris
fonte
1

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.

mcandal
fonte
1

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.

Khawaja Asim
fonte
O único problema com o PS é que ele demora a reagir e requer configuração para permitir a execução. Eu iria com um pequeno executável, um arquivo tt4 ou mesmo código embutido, que acho que qualquer programador pode escrever de uma maneira.
AaA
0

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

Brian Knoblauch
fonte
11
O VS é responsável por incrementar o último número, que geralmente é o número da compilação. Tudo o resto (ou seja, os números anteriores a isso) depende de você porque eles representam a versão do seu aplicativo.
Огњен Шобајић
11
Ог quiteен Шобајић: Não está bem. O esquema de numeração da Microsoft é major.minor.build.revision, por exemplo, 1.0.4.7. Se você definir a versão do assembly para algo como "1.0. *", O VS definirá os números de compilação e revisão para você. Nesse caso construção irá incrementar diariamente, e revisão será o número de segundos desde a meia-noite, dividido por 2.
Simon Tewsi
0

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.

John Denniston
fonte