Por que devo usar o MSBuild em vez dos arquivos da solução do Visual Studio?

Estamos usando o TeamCity para integração contínua e está criando nossos lançamentos por meio do arquivo de solução (.sln). Eu usei o Makefiles no passado para vários sistemas, mas nunca o msbuild (o que ouvi dizer é como Makefiles + XML mashup). Eu já vi muitas postagens sobre como usar o msbuild diretamente em vez dos arquivos de solução, mas não vejo uma resposta muito clara sobre por que fazê-lo.

Então, por que devemos nos preocupar em migrar de arquivos de solução para um 'makefile' do MSBuild? Temos alguns lançamentos que diferem de acordo com um #define (builds caracterizados), mas na maioria das vezes tudo funciona.

A maior preocupação é que agora teríamos que manter dois sistemas ao adicionar projetos / código-fonte.

ATUALIZAR:

As pessoas podem esclarecer o ciclo de vida e a interação dos três componentes a seguir?

1. O arquivo .sln do Visual Studio
2. Os vários arquivos .csproj no nível do projeto (que eu entendo de scripts "sub" do msbuild)
3. O script msbuild personalizado

É seguro dizer que o .sln e o .csproj são consumidos / mantidos normalmente na GUI do Visual Studio IDE enquanto o script msbuild personalizado é escrito à mão e geralmente consome o .csproj individual já existente "no estado em que se encontra"? Essa é uma maneira de ver redução de sobreposição / duplicação na manutenção ...

Gostaria de receber alguma luz sobre isso da experiência operacional de outras pessoas

O primeiro ponto é que o arquivo de solução se torna magicamente um arquivo MSBuild quando o MSBuild o executa - o que acontece quando você cria a solução no visual studio. Além disso, todos esses arquivos de projeto são apenas arquivos msbuild gerenciados pelo visual studio. De fato, os arquivos do projeto lidam com a maior parte do trabalho sujo real aqui, não importa se você está construindo a partir de soluções ou construindo a partir de um script personalizado do msbuild.

Também usamos o TeamCity para criar e publicar aplicativos e, normalmente, acabamos com scripts de msbuild personalizados para a maioria dos projetos. A função desses scripts - que não é realmente fácil com um arquivo de solução - é empacotar o projeto para implantação ou distribuição. Normalmente, esses scripts lidam com alguns aspectos mais operacionais das coisas - como construir o projeto da web em uma pasta específica ou copiar nas configurações em execução, em oposição às configurações de desenvolvimento. O trabalho pesado tende a ser tratado nos próprios arquivos do projeto - o script de construção apenas faz referência a eles, não tentamos recriar essa roda. No geral, funciona muito bem e não é realmente muito código duplicado.

O makefile para msbuild é o arquivo .sln (ou arquivo vcproj).

Uma linha de comando típica do msbuild seria algo como:

msbuild /p:Configuration=Release BigProject.sln

O objetivo do uso do msbuild é para que você possa criar scripts e automatizar o processo de compilação. Se você estava ciente disso ou não, o TeamCity vem usando o msbuild o tempo todo.

Deixe-me oferecer minha opinião sobre esta questão.

Embora você possa simplesmente usar o arquivo .SLN como seu 'processo de compilação', o próprio arquivo realmente não constitui um processo de compilação. O arquivo Solution é realmente apenas uma parte do Visual Studio e é usado para desenvolvimento. Mas o Visual Studio é apenas uma parte do processo de criação e lançamento. Você não pode confiar nas soluções para gerenciar sua construção, e as soluções certamente não oferecem uma situação de construção escalável.

Todo o objetivo de estabelecer um processo de criação é criar construções confiáveis. Ou seja, o processo de construção é tão confiável que, independentemente da configuração da construção, você obterá um resultado previsível. Toda vez, toda máquina. O resultado de uma construção previsível e confiável é que o processo de teste, implantação e liberação pode ser altamente automatizado, reduzindo ainda mais o risco de erro humano.

O estabelecimento de um processo de construção requer um investimento, mas em certos casos, o investimento é necessário. Aqui estão alguns fatores que favorecem um processo msbuild:

• Seu produto possui várias equipes (multifuncionais ou não) que estão trabalhando no mesmo projeto de equipe
• Sua organização possui apenas um projeto de equipe (deve ser o caso de 99% das lojas tradicionais, mesmo aquelas com mais de 200 desenvolvedores)
• Você tem mais de 20 projetos que precisam ser construídos, alguns dos quais dependem de outros e são mantidos por equipes diferentes
• Seu produto incorpora várias tecnologias .NET (C #, C ++, VB, F #, ASP.NET, etc) ou até mesmo tecnologias que não são da .NET (Grunt, node, npm, Java, etc)
• Seu produto possui dependências pesadas ou é construído sobre uma plataforma pesada. SharePoint, como um exemplo

Deixe-me dar um exemplo para expandir meu último ponto. Minha empresa atual faz desenvolvimento do SharePoint. O desenvolvimento do SharePoint, no mínimo, requer a instalação do SharePoint Foundation para executar compilações nos projetos do SharePoint. Falando em termos de um servidor de construção leve, é completamente impraticável exigir que o servidor de construção tenha o SharePoint instalado. O SharePoint não é apenas um animal com altos requisitos, mas teria sérias implicações de desempenho em uma compilação - e as compilações deveriam ser o mais rápidas e enxutas possível. A alavancagem do MSBuild permite eliminar esse requisito de instalação no servidor de compilação. De fato, nosso servidor de compilação não possui requisitos de instalação além da estrutura .NET (exigida pelo MSBuild) e do Node.

Como referência, eu recomendaria consultar este livro de Sayed Ibrahim Hashimi: http://www.amazon.com/Inside-Microsoft-Build-Engine-Foundation/dp/0735645248/ref=sr_1_fkmr0_1?ie=UTF8&qid=1412014650&sr= 8-1-fkmr0 & keywords = msbuild + confiável + compilação

Esta é exatamente a pergunta que me fiz há alguns meses! Tivemos tudo bem configurado:

• Arquivo de solução bem na raiz dos repositórios
• Crie etapas configuradas no Teamcity, como
  • Restaurar pacotes NuGet
  • Solução de compilação
  • Executar testes de unidade
  • Ambiente de teste de integração de configuração
  • Executar testes de integração
  • Derrube o ambiente de teste de integração
  • Crie um pacote de implantação
  • Criar script de migração

E então, quando se trata de reprodutibilidade, tornou-se aparente que essa pontuação era baixa. Quando você deixa o TeamCity ser seu script de construção, fica difícil reproduzir resultados semelhantes e confiáveis ​​em sua própria máquina de desenvolvimento.

Quando você possui um script de construção, ele sabe tudo o que precisa ser feito e possui todas as variáveis ​​no lugar. Quando você usa um servidor de IC como seu script de construção, e ocorre algum problema, como um teste complexo falhando ou precisando criar um pacote de implantação manualmente (como no meu exemplo), você precisa reunir todas as etapas da construção manualmente.

Então, resumindo , por que um script de compilação (MS)? Porque você acabará tendo mais requisitos quando se trata de sua compilação. Você provavelmente deseja executar alguns testes e gerar alguns artefatos a partir disso. Você provavelmente deseja fazer implantações. E quando tudo o que você deseja precisa ser executável, seja em um servidor de compilação ou na sua máquina, ele não pode terminar em nenhum outro lugar, exceto em um script de compilação.