Wie würden Sie ein DVCS (mercurial in meinem Fall) für verschiedene Versionen des .NET-Frameworks entwickeln?

Question

Ich schreibe eine Art neues Verwaltungs-Dashboard für unsere CMS (die auf ASP.net-Webforms ausgeführt wird). Einige unserer älteren Server können aus verschiedenen Gründen nur mit .NET 2.0 umgehen. Daher müsste ich meinen Code, der Lambda-Ausdrücke usw. verwendet, neu schreiben.

Ich frage mich, wie Sie eine dvcs wie Mercurial verwenden würden, um diese beiden Versionen gleichzeitig zu entwickeln.

Meine aktuelle Codebasis und mercurial Repository richtet sich an .NET 3.5. Ich bin relativ neu zu mercurial und ich denke, dass ich die Codebasis abzweigen müsste?

Best Practices oder Lernprogramme?

Answer 1

Ja, Sie können Mercurial dafür verwenden. Hier ist, wie es funktionieren würde.

Angenommen, Ihr aktueller Klon heißt new-dot-net, da er die neue .Net-Version unterstützt. Du machst einen Klon daraus und nennst ihn old-dot-net oder so ähnlich. Die beiden Klone sind jetzt identisch und beide Ziel. NET 3.5.

Nun vorsichtig kleine Änderungen vornehmen in old-dot-net, um es .Net 2.0 kompatibel zu machen. Wenn Sie die Änderungen die beiden Klone machen zu divergieren beginnen:

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

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

Hier machte man [c] und [d] Change das .Net 2.0 Kompatibilität hinzuzufügen. Beachten Sie, wie die old-dot-net Klon mehr Change als new-dot-net enthält, da sie die Abwärtskompatibilität Änderungen, die Sie nicht wollen in new-dot-net sehen. Wenn Sie fortfahren arbeiten, ist es wichtig, daran zu denken: net-dot-net enthält eine Teilmenge der Changesets in old-dot-net. Die Änderungen gehen von new-dot-net zu old-dot-net, aber nie in die entgegengesetzte Richtung.

Nehmen wir an, Sie machen eine neue Änderung in new-dot-net. Sie machen die Änderung in new-dot-net und die Situation sieht nun wie folgt aus:

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

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

Sie jetzt die Änderung old-dot-net auch, Sie Änderung old-dot-net und ziehen von net-dot-net an Back-Port wollen:

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

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

:

Dies wird eine new head in old-dot-net erstellen

seit dem [x] changeset hat [b] als Eltern Changeset. Sie haben jetzt haben multiple heads und müssen zusammenführen, um die Anzahl der Köpfe zu reduzieren. Durch das Zusammenführen erstellen Sie einen neuen Änderungssatz, der Ihre Art von sagt "so sollen [x] und kombiniert werden sollen".Wenn der [x] Änderungssatz nur Code berührt, der nicht auch in [c] und berührt wird, dann sollte die Zusammenführung einfach funktionieren. Andernfalls werden Sie mit einem Merge-Tool präsentiert und müssen den Konflikt lösen. Sie verpflichten sich, die merge als chageset [e]:

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

und fertig - Sie jetzt die [x] Änderung in Ihr .Net 2.0 kompatiblen Code eingebaut haben.

Dies wiederholen Sie jedes Mal, wenn eine Änderung in new-dot-net stattgefunden hat. Lassen Sie uns sagen, dass mehr Funktionen hinzugefügt werden:

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

Nachdem sie in old-dot-net ziehen Sie

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

und Sie jetzt fusionieren [e] und [z]:

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

die wichtigen Teile zu erinnern sind diese:

• machen Sie eine neue Funktionen in new-dot-net.
• Pull Änderungen in old-dot-net
• nie schiebenold-dot-net-new-dot-net.

Sollten Sie irgendwann feststellen, dass eine Änderung in new-dot-net ist nicht in old-dot-net benötigt, dann müssen Sie es immer noch in ziehen und es zu verschmelzen. Aber Sie werden dann eine Dummy Merge tun. Wenn die Köpfe sind [w] und [g], und Sie wollen [g] halten, dann tun

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

Die trick ist die Zusammenführung zu tun, ohne über die Ergebnisse Pflege, dann alle Änderungen rückgängig machen, und sich verpflichten, die unveränderte Arbeitskopie als die zusammenführen. Auf diese Weise sagen Sie der Welt, dass "die Kombination von [w] und [g][g] ist", d.h. Sie werfen die Änderungen in [w] weg. Neu Änderungen vorgenommen in new-dot-net nach [w] können dann wie normal zusammengeführt werden.