A empresa em que trabalho desenvolve um sistema em Delphi, que contém dezenas de módulos exe, e cada um deles é idêntico até certo ponto, no que diz respeito ao código-fonte. Infelizmente, ninguém nunca se importou em usar bibliotecas para inserir o código compartilhado. Isso significa que sempre que há uma correção de bug no código que todos esses módulos compartilham, um programador precisa fazer correções em todos eles separadamente! Sempre leva muito tempo ...

Decidi encontrar um método para colocar o código compartilhado nas bibliotecas. Eu considerei DLLs e BPLs. Nesse caso, as BPLs pareciam muito mais amigáveis ao programador e muito menos problemáticas, especialmente porque o código é usado apenas em nosso software e somente no Delph

Coloquei todo o código compartilhado por todos os módulos exe em BPLs e tudo parece bem, mas há certas coisas que não entendo e ficaria agradecido se você as explicasse para mim.

O que eu esperava depois de dividir o código em BPLs foi que seria suficiente implantar arquivos exe com os BPLs que eu criei. Mas acabou que eles precisam de um rtl100.bpl e vcl100.bpl também. Por que é tão? Quero implantar exes e apenas meus BPLs. Não quero fornecer aos usuários finais um monte de bibliotecas fornecidas pela Borland e por empresas de terceiros :). Eu quero que eles sejam compilados em exes, como costumavam ser compilados antes. É possível fazer isso?

O que eu fiz até agora foi:

Coloquei todas as unidades de pas compartilhadas nas BPLs. Cada BPL contém unidades pertencentes à mesma categoria, portanto, é claro para os programadores que código esperar em um determinado BP Cada BPL é uma biblioteca de "tempo de execução e designtime" Cada BPL é "reconstruído explicitamente". Os dois últimos são configurações de projeto padrão para BPL

E se trata dos projetos exe:

Excluí todas as unidades que eu havia colocado anteriormente nas BPL Instalei meus BPLs no menu Ferramentas-> Instalar pacote no BDS 2006. Nas configurações do meu projeto exe, marquei a opção "build with runtime packages" e listei todos os meus pacotes BPL na caixa de edição abaixo (apenas meus pacotes, pois limpei todos os outros que apareceram lá

Isso foi tudo o que fiz. Os projetos exe são compilados corretamente, mas não tenho acesso ao código fonte dos BPLs (não consigo navegar nesse código nos meus projetos exe), mesmo que todos os BPLs sejam armazenados junto com seus arquivos de código-fonte. Por quê? Parece estranho para mi

Eu sempre tendem a escrever descrições longas - desculpe por isso :). Agradeço sua ajuda. Eu só preciso de algumas palavras de explicação para os pontos que mencionei: implantar exe apenas com minhas BPLs, a correção do que eu fiz como um todo e a incapacidade de navegar nos códigos-fonte da BPL. Muito obrigado antecipadamente

Obrigado a todos pela discussão. Alguns disseram que a abordagem que escolhi não era uma boa ideia. Nosso software consiste em mais de 100 módulos (a maioria deles como drivers para dispositivos diferentes). A maioria deles compartilha o mesmo código - na maioria dos casos, classes. O problema é que essas classes nem sempre são colocadas em unidades de pas independentes e separadas. Quero dizer que o código compartilhado é frequentemente colocado em unidades que contêm código específico para um módulo. Isso significa que, quando você corrige um bug em uma classe compartilhada, não é suficiente copiar a unidade de pas em que está definida em todos os módulos de software e recompilá-los. Infelizmente, você precisa copiar e colar os trechos de código fixos em cada módulo, um por um, em uma unidade e classe adequadas. Isso leva muito tempo e é isso que eu gostaria de eliminar, escolhendo uma abordagem correta - por favor me ajude.

Eu pensei que usar BPLs seria uma boa solução, mas tem algumas desvantagens, como alguns de vocês mencionaram. O pior problema é que, se cada EXE precisar de vários BPLs, nosso pessoal de suporte técnico precisará saber qual EXE precisa de quais BPLs e fornecer aos usuários finais os arquivos adequados. Desde que não tenhamos um atualizador de software, isso será um grande negócio para nossos técnicos e usuários finais. Eles certamente se perderão e ficarão zangados: - /.

Também podem ocorrer problemas de compatibilidade - se um BPL for compartilhado por muitos EXEs, uma modificação de um BPL pode ser boa para um EXE e ruim para alguns outros - @Warren P.

O que devo fazer para tornar mais rápida a correção de erros em tantos projetos? Penso em uma das seguintes abordagens. Se você tiver idéias melhores, entre em contato.

Coloque o código compartilhado em unidades de pas separadas e autônomas; portanto, quando houver uma correção de bug em uma delas, basta copiá-lo para todos os projetos (sobrescrever os arquivos antigos) e recompilar todos ele

Esta solução parece estar correta, na medida em que um código modificado pela retaguarda for concretizado. Mas também temos unidades de pas com funções e procedimentos de uso geral, que geralmente não modificam modificações - adicionamos novas funções sempre que necessário, mas em projetos únicos. Imagine que você escreva uma nova função em um dos 100 módulos e a coloque em sua unidade de uso geral. Depois de um mês ou dois, você modifica um módulo diferente e acha que precisa da mesma função que escreveu há 2 meses. Você precisa encontrar o módulo (é difícil se você não se lembra qual era) e copiar a função no seu código. E obviamente - as unidades de uso geral tornam-se completamente diferentes em cada módulo, desde que sejam armazenadas em cada projeto separadamente. E então, se houver uma correção de bug a ser executada ... toda a história se repete.

Crie BPLs para todo o código compartilhado, mas vincule-os aos EXEs, para que os EXEs sejam independente

Para mim, parece a melhor solução agora, mas existem vários contras. Se eu corrigir um bug em uma BPL, cada programador precisará atualizar as BPLs no computador. E se eles esquecerem? Mas ainda assim, acho que é um problema menor. Se cuidarmos de nos informar sobre as mudanças, tudo ficará be

@ CodeInChaos: Não sei se entendi direito. Você quer dizer compartilhar arquivos pas entre projetos? Como fazer isso? Armazenamos códigos-fonte no SVN. Isso significa que teríamos que armazenar código compartilhado em uma pasta separada e fazer com que todos os projetos pesquisassem esse código, certo? E baixe do SVN um projeto e todas as pastas das quais depende ...

Por favor, me ajude a escolher uma boa solução. Só não quero que a empresa perca muito mais tempo e dinheiro do que o necessário em correções de erros apenas por causa de uma abordagem estúpida ao desenvolvimento de softwar

Muito obrigado