Arquivos app.config / web.config específicos do desenvolvedor no Visual Studio

Temos vários projetos .NET onde armazenamos certas configurações nos arquivos de configuração.

Agora, cada desenvolvedor terá seus próprios arquivos de configuração que diferem um pouco (strings de conexão diferentes para se conectar a bancos de dados locais, terminais WCF diferentes , etc.)

No momento, temos a tendência de verificar os arquivos app / web.config e modificá-los para atender às nossas necessidades.

Isso leva a muitos problemas, pois de vez em quando alguém verifica suas próprias configurações ou perde a configuração personalizada ao obter a versão mais recente do TFS .

Como você lida com situações como essa? Ou você não tem esse problema?

Usamos um sistema que combina várias das respostas existentes nesta página, além de recorrer a esta sugestão de Scott Hanselman .

Resumindo, o que fizemos foi ter um app.config / web.config comum e ter a maioria das configurações específicas em arquivos individuais, conforme sugerido por outras respostas aqui. por exemplo, para nossas configurações de SMTP, o app.config contém

<system.net>
  <mailSettings>
    <smtp configSource="config\smtp.config" />
  </mailSettings>
</system.net>

Este arquivo está no controle de origem. No entanto, os arquivos individuais, como este, não são:

<?xml version="1.0" encoding="utf-8" ?>
<smtp deliveryMethod="Network">
  <network host="127.0.0.1" port="25" defaultCredentials="false" password="" userName ="" />
</smtp>

Mas não é bem aí que a história termina. E quanto a novos desenvolvedores ou uma nova instalação de código-fonte? A maior parte da configuração não está mais no controle de origem, e é uma dor construir manualmente todos os arquivos .config de que precisam. Eu prefiro ter uma fonte que pelo menos compile direto da caixa.

Portanto, mantemos uma versão dos arquivos .config no controle de origem, denominados arquivos .config.default . Uma nova árvore de origem, portanto, tem a seguinte aparência:

Ainda assim, não tem nenhuma utilidade para o desenvolvedor, já que para o Visual Studio eles são apenas arquivos de texto sem sentido. Portanto, o arquivo em lote copy_default_config.bat,, se encarrega de criar um conjunto inicial de arquivos .config a partir dos arquivos .config.default:

@echo off
@REM Makes copies of all .default files without the .default extension, only if it doesn't already exist. Does the same recursively through all child folders.
for /r %%f in (*.default) do (
    if not exist "%%~pnf" (echo Copying %%~pnf.default to %%~pnf & copy "%%f" "%%~pnf" /y)
)
echo Done.

O script pode ser reexecutado com segurança, pois os desenvolvedores que já possuem seus arquivos .config não os substituirão. Portanto, pode-se concebivelmente executar esse arquivo em lote como um evento de pré-construção. Os valores nos arquivos .default podem não ser exatamente corretos para uma nova instalação, mas são um ponto de partida razoável.

Em última análise, o que cada desenvolvedor acaba tendo é uma pasta de arquivos de configuração que se parece com isto:

Pode parecer um pouco complicado, mas é definitivamente preferível ao incômodo de desenvolvedores pisando nos calos dos outros.

Em seu Web.config, use a fonte de outros arquivos

<configuration>
    <connectionStrings configSource="ConnectionStrings.config" />
...
</configuration>

Mantenha o web.config no controle de versão e não o faça para ConnectionStrings.config. Agora todos os desenvolvedores têm um arquivo para a string de conexão.

Você pode fazer isso para todas as configurações que dependem do local.

Aqui está uma solução para arquivos web.config e Visual Studio 2010:

1) Edite manualmente o arquivo .csproj do seu aplicativo da web para adicionar um AfterBuilddestino como este:

  <Project>
   ...
    <Target Name="AfterBuild">
      <Copy SourceFiles="web.config" DestinationFiles="obj\$(Configuration)\tempweb.config" />
      <TransformXml Source="obj\$(Configuration)\tempweb.config"
                  Transform="web.$(USERNAME).config"
                  Destination="obj\$(Configuration)\tempweb2.config" />
      <ReadLinesFromFile File="obj\$(Configuration)\tempweb2.config"><Output TaskParameter="Lines" ItemName="TransformedWebConfig"/></ReadLinesFromFile>
      <ReadLinesFromFile File="web.config"><Output TaskParameter="Lines" ItemName="UnTransformedWebConfig"/></ReadLinesFromFile>
      <Copy Condition=" @(UnTransformedWebConfig) != @(TransformedWebConfig) " SourceFiles="obj\$(Configuration)\tempweb2.config" DestinationFiles="web.config" OverwriteReadOnlyFiles="True" />
    </Target>
  </Project>

Esse destino transformará o arquivo Web.config correspondente ao desenvolvedor atual conectado - daí a $(USERNAME)variável -, com o arquivo correspondente criado em 1). Ele substituirá o Web.config local apenas se o conteúdo for alterado (para evitar a reinicialização) em cada compilação, mesmo se o Web.config local for controlado por origem, é por isso que OverwriteReadOnlyFilesestá definido como True. Este ponto é de fato discutível.

2) Crie um arquivo com o nome Web.[developer windows login].configde cada desenvolvedor do projeto. (por exemplo, nas capturas de tela a seguir, tenho dois desenvolvedores chamados smo e smo2):

Esses arquivos (1 por desenvolvedor) podem / devem ser controlados pela fonte. Eles não devem ser marcados como dependentes do Web.config principal porque queremos verificá-los individualmente.

Cada um desse arquivo representa uma transformação a ser aplicada ao arquivo Web.Config principal. A sintaxe de transformação é descrita aqui: Web.config Sintaxe de transformação para implantação de projeto de aplicativo da web . Reutilizamos esta tarefa de transformação de arquivo Xml que vem pronta para uso com o Visual Studio. O objetivo desta tarefa é mesclar elementos e atributos Xml em vez de sobrescrever todo o arquivo.

Por exemplo, aqui está um exemplo web.[dev login].configque altera uma string de conexão chamada 'MyDB', independentemente do resto do arquivo Web.config:

<?xml version="1.0"?>
<configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
    <connectionStrings>
      <add name="MyDB" 
        connectionString="Data Source=ReleaseSQLServer;Initial Catalog=MyReleaseDB;Integrated Security=True" 
        xdt:Transform="SetAttributes" xdt:Locator="Match(name)" />
    </connectionStrings>
</configuration>

Agora, esta solução não é perfeita porque:

• após a construção, os desenvolvedores podem ter um Web.Config diferente localmente do que no sistema de controle de origem
• eles podem ter que forçar a gravação local ao obter um novo Web.Config do sistema de controle de origem
• os desenvolvedores não devem fazer check-out / no web.config principal. Deve ser reservado para poucas pessoas.

Mas, pelo menos, você só precisa manter um web.config principal exclusivo, mais um arquivo de transformação por desenvolvedor.

Uma abordagem semelhante poderia ser adotada para arquivos App.config (não web), mas não entrei em detalhes.

Estamos usando machine.config para evitar diferenças no web.config entre os ambientes.

Que tal ignorar o arquivo, para que nunca seja verificado? Eu encontrei um problema semelhante e adicionei web.config à lista de ignorados no Subversion.

No entanto, no TFS é um pouco mais difícil, veja este post sobre como fazer isso.

Uma maneira de lidar com isso é ter um sistema tokenizado e usar um script rake para alterar os valores.

Um método mais rudimentar poderia ser ter um link para um arquivo AppSettings.config para todos os AppSettings em seu web.config (semelhante com conexões), ou seja,

<appSettings configSource="_configs/AppSettings.config" />

Em seguida, tenha uma pasta com cada um de seus desenvolvedores tem uma versão em uma subpasta (ou seja, / _configs / dave /). Então, quando um desenvolvedor está trabalhando em seu próprio código, ele copia da subpasta para a raiz da pasta vinculada.

Você precisará comunicar as alterações a esses arquivos (a menos que você faça token). Se você mantiver o arquivo AppSettings.config fora do controle de origem e apenas verificar as pastas individuais do desenvolvedor (todas elas), eles serão forçados a copiar a correta.

Eu prefiro a tokenização, mas pode ser mais difícil de colocar em funcionamento se isso for apenas uma solução rápida.

Ignore os arquivos e tenha um Commom_Web.Config e Common_App.Config. Usando um servidor de construção de integração contínua com tarefas de construção que renomeiam esses dois para nomes normais para que o servidor de construção possa fazer seu trabalho.

Temos o mesmo problema e o que estamos fazendo é

• Verifique o web.config com os valores de testserver / production
• O desenvolvedor vai para o Windows Explorer e altera o modo somente leitura do arquivo
• Edite a configuração para se adequar ao seu ambiente.
• O check-in no web.config ocorre apenas quando os valores de implantação são alterados ou qualquer entrada de configuração é adicionada ou excluída.
• Isso precisa de uma boa quantidade de comentários para cada entrada de configuração, pois precisa ser alterado por cada dev

Supondo que você esteja usando o Visual Studio, por que não usa configurações de solução diferentes? Por exemplo: você pode ter uma configuração de depuração que usa Web.config.debug e uma configuração de versão que usa Web.config.release. Web.config.debug deve ter algo como

<appSettings file="C:/Standard_Path_To_Configs/Standard_Name_For_Config.config"> 

com o arquivo Standard_Name_For_Config.config que obtém todas as configurações pessoais do desenvolvedor, enquanto o Web.config.release sempre tem as configurações de produção. Você pode armazenar configurações padrão em alguma pasta de origem controlada e fazer com que um novo usuário as tire de lá.