Eu verifico o código gerado no controle de origem ou não? [duplicado]

35

Estou desenvolvendo um aplicativo .Net que usa buffers de protocolo do google. Historicamente, o aplicativo usava a abordagem, defendida pela equipe de protobufnet, de decorar as classes com atributos, em vez de usar arquivos .proto.

Agora estou no processo de migrar parte do cliente do aplicativo para outra tecnologia e há um strong desejo de começar a usar os arquivos .proto como autoridade para que as duas tecnologias possam interoperar.

Meu plano é gerar automaticamente o C # do .proto, no entanto, minha pergunta é se devo verificar os arquivos resultantes de volta ao controle de origem? Note que espero que o processo de geração de código seja rápido.

Como escolho a abordagem apropriada para o caso acima? Qual é considerada a melhor prática?

    
por Dave Hillier 27.03.2013 / 14:16
fonte

5 respostas

48

Como regra geral, os arquivos gerados não pertencem ao repositório do código-fonte.

O maior risco que você corre quando coloca esses arquivos no repositório é que eles ficam fora de sincronia com sua origem e a compilação é executada com arquivos de buffer de protocolo diferentes do que você pensaria com base nos arquivos .proto.

Algumas razões para se desviar da regra geral são

  • Seu ambiente de criação não pode manipular a etapa de criação adicional automaticamente. Se você tiver que gerar os arquivos manualmente para cada construção, você pode colocá-los no VCS. Então, na verdade, reduz o risco de uma incompatibilidade de versão, porque menos pessoas precisam executar a etapa de geração.
  • A etapa de geração diminui significativamente sua compilação
  • Depois de gerá-los, os arquivos são modificados manualmente. Nesse caso, eles não são mais arquivos gerados e, portanto, pertencem ao VCS.
  • Os arquivos de origem são alterados muito raramente (por exemplo, eles vêm de um terceiro que fornece atualizações apenas a cada poucos meses).
por 27.03.2013 / 14:32
fonte
15

Em primeiro lugar, o software de controle de versão está lá para ajudá-lo a fazer o seu trabalho. Então, a primeira pergunta que você faz não deve ser "devo colocar X no controle de versão?" mas sim "vai colocar o X no controle de versão me ajudar?" Muitas vezes, esses dois têm a mesma resposta, mas nem sempre.

Em outras palavras, em vez de perguntar nós se achamos que esses arquivos devem estar no controle de versão ou não, pergunte a si mesmo se isso é útil para você . Se a geração dos arquivos for rápida, qual valor existe para salvar os dados gerados? Seus scripts de construção são projetados de forma que sempre gerem os arquivos ou eles primeiro procuram para ver se algo está no disco?

Você também deve se perguntar se é importante ter um registro concreto do que aconteceu em uma construção. Se você precisar reproduzir precisamente uma compilação, poderá ser útil ter esses arquivos no controle de origem. É concebível que uma compilação futura possa usar uma versão mais nova da ferramenta que gere arquivos ligeiramente diferentes - embora outra opção seja também controlar as ferramentas por versão.

A questão é: não se preocupe tanto com o que você deve ou não deve fazer com base nas idéias de alguém sobre um padrão, faça o que é melhor para o seu projeto. Só você pode responder isso, já que não conhecemos todas as restrições e requisitos com os quais você está lidando.

    
por 27.03.2013 / 15:03
fonte
7

Muitos arquivos em .net são gerados automaticamente pelo Visual Studio; no entanto, geralmente verificamos isso para que qualquer pessoa que verifique o código-fonte tenha uma versão completa que seja compilada e executada. (Veja, por exemplo, classes feitas a partir de arquivos xsd para desserializar xml.)

Eu veria esses arquivos da mesma maneira; eles são código-fonte C # que foi gerado através de uma ferramenta, mas que é necessário para o programa construir. Portanto, verifique-os.

    
por 27.03.2013 / 16:37
fonte
5

Se não houver modificação nos arquivos gerados, não há sentido em colocá-los no controle de versão. Você não coloca binários compilados no controle de versão, certo? Uma regra básica com controle de versão é que você não precisa colocar nada no controle de versão, que pode ser gerado a partir de outros arquivos. É claro que se a geração for de alguma forma complicada ou demorar muito, pode não ser prática.

    
por 27.03.2013 / 14:26
fonte
5

Parece que você está se referindo ao que O Programador Pragmático chama geração de código passivo .

Passive code generators save typing. [...] Once the result is produced, it becomes a full-fledged source file in the project; it will be edited, compiled, and placed under source control just like any other file.

Uses:

  • Creating new source files
  • Performing one-off conversions among programming languages
  • Producing lookup tables and other resources that are expensive to compute at runtime

Eu colocaria os arquivos de origem gerados para qualquer um dos seguintes itens:

  • Se você estiver planejando modificar o código C # gerado
  • Se você quiser evitar gerar o código antes de executar em ambientes dev? Por exemplo. se uma ferramenta precisa ser instalada para fazer a geração
  • Se o processo de geração for demorado
por 27.03.2013 / 15:10
fonte