Comment utiliseriez-vous un DVCS (mercurial dans mon cas) pour développer des versions différentes du framework .NET?

Question

J'écris une sorte de nouveau tableau de bord d'administration pour nos cms (qui fonctionne sur les webmestres asp.net). Certains de nos anciens serveurs ne peuvent gérer que .NET 2.0 pour diverses raisons, donc je devrais réécrire mon code qui utilise des expressions lambda, etc.

Je me demande comment utiliser un dvc comme mercurial pour développer ces deux versions simultanément.

Mon référentiel de base de données courant et mercurial cible le .NET 3.5. Je suis relativement nouveau à mercurial et je suppose que je devrais branche le codebase?

Des bonnes pratiques ou des tutoriels?

Answer 1

Oui, vous pouvez utiliser Mercurial pour cela. Voici comment cela fonctionnerait. Supposons que votre clone actuel s'appelle new-dot-net puisqu'il prend en charge la nouvelle version .Net. Vous en faites un clone et vous l'appelez old-dot-net ou quelque chose comme ça. Les deux clones sont maintenant identiques et les deux cibles .Net 3.5.

Maintenant, faites soigneusement de petits changements dans old-dot-net afin de le rendre . Net 2.0 compatible. Lorsque vous effectuez les modifications les deux clones vont commencent à diverger:

 
new-dot-net: ... [a] --- [b] 

old-dot-net: ... [a] --- [b] --- [c] --- [d] 

Ici vous fait [c] et [d] changesets ajouter la compatibilité .Net 2.0 . Notez comment le clone old-dot-net contient plus de changesets que new-dot-net puisqu'il a la rétrocompatibilité changements que vous voulez voir new-dot-net. Comme vous continuez de travail, il est important de penser à ceci: net-dot-net contiendra un sous-ensemble des changesets dans old-dot-net. Les changements passent de new-dot-net à old-dot-net, mais jamais dans la direction opposée.

Supposons que vous apportiez une nouvelle modification dans new-dot-net. Vous faites le changement dans new-dot-net et la situation ressemble maintenant à ceci:

 
new-dot-net: ... [a] --- [b] --- [x] 

old-dot-net: ... [a] --- [b] --- [c] --- [d] 

Vous voulez maintenant rétroporter le changement de old-dot-net ainsi, vous changement old-dot-net et tirer de net-dot-net:

% cd old-dot-net 
% hg pull ../new-dot-net 

Cela va créer un new head dans old-dot-net:

 
          [x] 
          /
old-dot-net: ... [a] --- [b] --- [c] --- [d] 

depuis le [x] changeset a [b] comme son parent changeset. Vous avez maintenant ont multiple heads et doivent fusionner pour réduire le nombre de têtes . En fusionnant vous créez un nouveau changeset qui est votre façon de en disant "c'est ainsi que [x] et [d] doivent être combinés".Si le changeet ne touche que le code qui n'est pas également touché dans [c] et [d], alors la fusion devrait simplement fonctionner. Sinon, vous serez présenté avec un outil de fusion et devrez résoudre le conflit. Vous vous engagez la fusion comme chageset [e]:

 
          [x] --------------. 
          /     \ 
old-dot-net: ... [a] --- [b] --- [c] --- [d] --- [e] 

Et vous avez terminé - vous avez maintenant intégré le changement [x] dans votre code compatible .Net 2.0.

Vous répétez cette opération chaque fois qu'il y a eu un changement dans new-dot-net. Disons que plus de fonctionnalités sont ajoutées:

 
new-dot-net: ... [a] --- [b] --- [x] --- [y] --- [z] 

Après les tirant dans old-dot-net vous

 
          [x] --------------.---- [y] --- [z] 
          /     \ 
old-dot-net: ... [a] --- [b] --- [c] --- [d] --- [e] 

Et vous maintenant fusionner [e] et [z]:

 
          [x] --------------.---- [y] --- [z] 
          /     \    \ 
old-dot-net: ... [a] --- [b] --- [c] --- [d] --- [e] ----------- [f] 

Les parties importantes à retenir sont les suivants:

• rendre nouvelles fonctionnalités en new-dot-net.
• traction changements dans old-dot-net
• ne poussentold-dot-net-new-dot-net.

Si vous trouvez à un moment donné qu'un changement de new-dot-net n'est pas nécessaire à old-dot-net, alors vous avez encore besoin de le tirer et la fusion elle. Mais vous ferez ensuite une fusion fictive . Si les têtes sont [w] et [g], et que vous voulez garder [g], puis faire

% HGMERGE=true hg merge -y 
% hg revert --all --rev g 
% hg commit -m 'Dummy merge with y.' 

Le trick est de faire de la fusion sans se soucier des résultats, nous revenions alors tous les changements, et engager la copie de travail inchangée la fusion . De cette façon, vous dites au monde que "la combinaison de [w] et [g] est [g]", c'est-à-dire que vous jetez les changements dans [w]. Nouveau modifications apportées en new-dot-net après [w] peuvent ensuite être fusionnés comme normal.