Qual é exatamente o número da compilação em MAJOR.MINOR.BUILDNUMBER.REVISION

O que penso sobre os números de compilação é que, sempre que uma nova compilação noturna é criada, um novo BUILDNUMBER é gerado e atribuído a essa compilação. Portanto, para o meu aplicativo da versão 7.0, as versões noturnas serão 7.0.1, 7.0.2 e assim por diante. É assim? Então, qual é a utilidade de uma REVISÃO após o número da compilação? Ou a parte REVISION está sendo incrementada após cada compilação noturna? Estou um pouco confuso aqui ... nos referimos a cada construção noturna como CONSTRUTOR ?

O formato é mencionado aqui: AssemblyVersion - MSDN

Eu nunca vi isso escrito dessa forma. Onde trabalho, estamos usando o formulário MAJOR.MINOR.REVISION.BUILDNUMBER, em que MAJOR é uma versão principal (geralmente muitos novos recursos ou alterações na interface do usuário ou no SO subjacente), MINOR é uma versão secundária (talvez alguns novos) em uma versão principal anterior, REVISION geralmente é uma correção para uma versão secundária anterior (sem nova funcionalidade) e BUILDNUMBER é incrementado para cada versão mais recente de uma revisão.

Por exemplo, uma revisão pode ser liberada para o controle de qualidade (controle de qualidade) e eles retornam com um problema que requer uma alteração. O bug seria corrigido e liberado de volta ao controle de qualidade com o mesmo número de REVISION, mas um BUILDNUMBER incrementado.

Toda a confusão decorre das diferentes semânticas que a MS usa para "Build number" e especialmente "Revision". Os termos significam apenas coisas diferentes.

A maioria das pessoas (inclusive eu) usa um esquema de numeração de versão semântica, onde você obtém um número BUILD mais alto sempre que precisar criar uma nova compilação por qualquer motivo. Para nós, um hotfix é considerado apenas mais uma alteração de código, e a parte BUILD aumenta automaticamente a cada execução de IC. Módulos com o mesmo MAJ.MIN.REV são considerados intercambiáveis ​​e o BUILD informa qual é o mais recente.

A REVISÃO incremental, no entanto, indica um novo ramo de lançamento permanente, é por isso que o colocamos antes do BUILD. A desvantagem dessa abordagem é que podemos obter a seguinte sequência de eventos:

• confirmar número 4711: Alice adicionou o recurso A
• O IC produz a compilação 1.2.3.100
• confirmar número 4712: recurso modificado Bob B
• confirmar número 4713: Alice corrigiu o recurso A (o "hotfix")
• O IC produz a compilação 1.2.3.101

Como você pode ver, o hotfix não é a única alteração contida na próxima compilação, também a modificação de Bob se torna parte dessa compilação. Se você quiser estabilizar a ramificação atual, poderá ter problemas, pois nunca poderá ter certeza se Bob acabou de adicionar um monte de bugs.

A Microsoft usa os dois termos de maneira diferente. O número BUILD não é incrementado automaticamente; em vez disso, pode ser considerado como uma ramificação de liberação, para congelar o código usado para uma versão específica do código. A REVISION indica alterações "quentes" adicionais aplicadas a essa ramificação BUILD. A sequência seria, portanto, a seguinte:

• confirmar número 4711: Alice adicionou o recurso A ao tronco / mestre
• Carl cria ramo de construção 1.2.100
• O IC produz a compilação 1.2.100.0
• confirmar número 4712: Bob modificou o recurso B no tronco / mestre
• confirmar número 4713: Alice corrigiu o recurso A na 1.2.100ramificação
• O IC produz a compilação 1.2.100.1

O termo REVISÃO pode se referir a

• uma revisão do produto (é assim que a maioria das pessoas a usa)
• uma revisão de uma compilação diária específica (é o que a MS faz)

A principal diferença entre os dois processos é se você deseja ou não aplicar hotfixes às compilações de IC e, portanto, em que ponto do processo a ramificação é feita. Esse aspecto se torna importante quando você deseja escolher uma compilação específica a qualquer momento após todos os testes terem sido bem-sucedidos e promover exatamente essa versão para a próxima versão oficial do seu produto.

No nosso caso, a ferramenta de IC cria uma tag de repositório, para que sempre tenhamos as informações necessárias prontas para uso, quando necessário. Com o SVN, torna-se ainda mais simples, porque as tags e ramificações são implementadas exatamente da mesma maneira - uma tag nada mais é do que uma ramificação localizada abaixo /tags.

Veja também

Na seção Perguntas frequentes na estratégia de ramificação do TFS :

Em que ramo devo corrigir o ticket P1 (hotfix)?

• O P1 deve ser corrigido na ramificação mais próxima da base de código em execução na produção. Nesse caso, o P1 deve ser corrigido no ramo Prod. Ao aplicar a correção em qualquer outra ramificação e implementar as alterações na produção, você corre o risco de liberar código semiacabado ou não testado das iterações subseqüentes.

• Agora você pode argumentar se é seguro trabalhar diretamente contra o ramo Prod, pense novamente, um P1 que requer atenção imediata não deve ser um problema fundamental no sistema. Caso seja um problema fundamental, ele deve ser adicionado ao backlog do produto, pois pode exigir análises e discussões adicionais com o cliente.

Outra boa leitura é o guia de ramificação do TFS

A Microsoft descreve o objetivo de cada componente de um número de versão do .NET na documentação do MSDN para a Versionclasse. Aqui está a parte relevante:

major.minor [.build [.revision]]

Os componentes são usados ​​por convenção da seguinte maneira:

Principal: montagens com o mesmo nome, mas diferentes versões principais não são intercambiáveis. Um número de versão mais alto pode indicar uma reescrita principal de um produto em que a compatibilidade com versões anteriores não pode ser assumida.

Secundário: se o nome e o número da versão principal em dois conjuntos forem iguais, mas o número da versão secundária for diferente, isso indica aprimoramento significativo com a intenção de compatibilidade com versões anteriores. Esse número menor de versão secundária pode indicar um lançamento pontual de um produto ou uma nova versão totalmente compatível com versões anteriores.

Compilação: uma diferença no número da compilação representa uma recompilação da mesma fonte. Números de compilação diferentes podem ser usados ​​quando o processador, a plataforma ou o compilador é alterado.

Revisão: montagens com o mesmo nome, números de versão principais e secundários, mas revisões diferentes devem ser totalmente intercambiáveis. Um número de revisão mais alto pode ser usado em uma construção que corrige uma falha de segurança em uma montagem liberada anteriormente.

http://msdn.microsoft.com/en-us/library/system.version.aspx

Há pelo menos algumas coisas diferentes que eu poderia imaginar a referência do número de compilação:

1. Versão de controle de origem que foi lançada. Por exemplo, se houve uma versão da revisão # 12345, isso pode ser rastreado com o número de compilação e, se for corrigido, é aí que as revisões poderão subir, pois não é uma nova funcionalidade que aumentaria as versões principais ou secundárias e o número da compilação deve ser lembrado caso alguém queira executá-la novamente.

2. Identificador do servidor de integração contínua. Nesse caso, o servidor de IC pode numerar cada compilação executada e, portanto, o número da compilação é o que uma compilação obtém com êxito e a parte de revisão não é necessária nesse cenário.

Pode haver outros que eu não conheço, mas esses são os grandes que eu conheço quando se trata de números em bases de código.

Um número de compilação geralmente é incrementado a cada compilação, portanto é único.

Por uma questão de simplicidade, alguns redefinem o número da compilação sempre que os números MAJOR ou MINOR são reduzidos.

A maioria dos mecanismos de integração contínua permite números de compilação exclusivos gerados automaticamente.

A revisão pode ser usada para correções das compilações. Digamos que duas equipes trabalhem em um produto.

A equipe 1 é a principal equipe de desenvolvimento e produz a construção noturna com o seguinte esquema de versão 1.0.X.0, em que o X é incrementado. Agora eles estão na versão 1.0.50.0. A equipe 2 está desenvolvendo uma versão de tempos em tempos. Digamos que eles usem a compilação da semana passada, que é 1.0.43.0, e comecem a usá-la. A equipe 1 avança para 1.0.51.0 quando a equipe 2 encontra um problema na 1.0.43.0.

Agora a equipe 1 fará a compilação (43), corrigirá o problema e fornecerá à equipe 2 a compilação 1.0.43.1. A correção também pode ser propagada na compilação principal, portanto a alteração aparecerá na 1.0.52.0.

Espero que isso seja claro e útil.

* A revisão é útil quando nem todos os envolvidos no projeto usam a mesma compilação e você precisa corrigir compilações específicas.

Deixe-me dizer como eu o vejo e o uso ....

Versão do ProgramName major.minor.build.revision

major: Para mim, é o projeto atual em que estou trabalhando. O número não será alterado até eu iniciar um novo projeto com o mesmo nome de programa. Isso significa que literalmente escreverei um novo programa do mesmo sexo (exemplo: acesso v1 - acesso v-2 - acesso v-3 * todo o mesmo programa, mas totalmente reescrito).

menor: significa que estou adicionando funcionalidade ao projeto publicado atual. Por exemplo, talvez eu tenha adicionado a capacidade de imprimir um recibo ou a capacidade de importar fotos. Basicamente, funcionalidade adicional que desejo adicionar agora e não esperar pelo próximo grande lançamento.

build: Isso eu uso para indicar alterações muito pequenas na versão major.minor publicada. Isso pode ser uma alteração no layout, esquema de cores etc.

revisão: Utilizo para indicar uma correção de bug no major.minor.build publicado atualmente - Há ocasiões em que não estou avançando no projeto atual e surge um bug. Este bug precisa ser corrigido e publicado. Significa apenas que estou corrigindo o que já publiquei para funcionar corretamente. Eu também usaria isso se estiver trabalhando em uma nova compilação, uma nova adição ou inicie uma nova versão principal. Obviamente, a versão publicada precisa ser corrigida enquanto aguardamos o próximo lançamento principal, secundário ou de compilação.

Portanto, dessa maneira, um projeto finalizado ou paralisado ainda pode ser corrigido e utilizado até que o próximo lançamento seja publicado.

Espero que isso dê a alguém uma melhor compreensão de como esse tipo de versão funcionaria (ou deveria). Para mim, é a única definição e prática que faz algum tipo de sentido real ao usar esse tipo de controle de versão.

Eu só vi um número de compilação como o último número no ID da versão. Não tenho certeza de como você apresentaria uma revisão para um número de compilação. Suponho que, se você alterou alguns dos recursos não criados (ícones, script de banco de dados, etc.), talvez, mas a maioria dos projetos em que trabalhei recentemente tem todas essas coisas sob controle de versão também, então o processo de compilação os seleciona quando fazendo o instalador / liberação. Eu gosto de números de compilação com registro de data e hora, embora não exatamente como o @David descreve (eu gosto de major.minor.revision.HHMM). No entanto, onde trabalho, usamos apenas um número seqüencial que nosso servidor de compilação gera.

Como o jkohlhepp, usamos a terceira parte da versão para mostrar o número da revisão no SubVersion e a quarta para mostrar o número da versão do nosso servidor de integração contínua (Jenkins para nós). Isso nos oferece vários benefícios - ter o número da versão definido pelo servidor de IC remove uma etapa manual que, de outra forma, poderia ser perdida acidentalmente; é fácil verificar se um desenvolvedor não fez uma versão atrevida do PC de desenvolvimento (o que resultaria em esses números serem zero); e nos permite vincular qualquer parte do software ao código que foi gerado e ao trabalho de IC que o criou, apenas olhando o número da versão - que ocasionalmente achamos muito útil.

É o que você quer que seja. Eu costumo usar year.month.day.hhmm para minha revisão principal.minor.build. Se estou produzindo mais de um por minuto, algo está errado. você pode simplesmente usar um incremento simples, ou eu já vi alguns geradores elaborados para eles. O que você quer que seja? O que eles precisam fazer é torná-lo para que você chegue à fonte usada para criar essa saída, para que você possa fazer isso.

Os últimos dois dígitos são o número total da compilação

1.01.2.1234

o número da compilação é 2.1234, no entanto, a maioria das pessoas usará apenas 1234, pois a parte 2 não muda com frequência.

Nossa equipe usa o terceiro número (revisão) como o número de revisão do repositório Subversion. Usamos o quarto número (compilação) como o número de compilação do nosso servidor de integração contínua TeamCity que realmente cria a compilação. O TeamCity cria um novo arquivo AssemblyInfo com os #s corretos durante o processo de compilação.