Как Вы использовали бы DVCS (подвижный в моем случае) для разработки для различных версий платформы.NET?

Да, для этого вы можете использовать Mercurial. Вот как это будет работать.

Допустим, ваш текущий клон называется new-dot-net , поскольку он поддерживать новую версию .Net. Вы делаете его клон и называете old-dot-net или что-то в этом роде. Два клона теперь идентичны и оба нацелены на .Net 3.5.

Теперь осторожно внесите небольшие изменения в old-dot-net , чтобы сделать его .Net 2.0 совместим. Когда вы внесете изменения, два клона будут начинают расходиться:

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

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

Здесь вы внесли изменения [c] и [d] , чтобы добавить .Net 2.0 совместимость. Обратите внимание, что клон old-dot-net содержит больше ревизий, чем new-dot-net , поскольку он имеет обратную совместимость изменения, которые вы не хотите видеть в new-dot-net . Как вы продолжаете работая, важно подумать об этом: net-dot-net будет содержать подмножество ревизий в old-dot-net . Изменения вытекают из new-dot-net на old-dot-net , но никогда в обратном направлении.

Допустим, вы вносите новое изменение в ] новая точка-сеть . Вы вносите изменения в new-dot-net , и теперь ситуация выглядит следующим образом:

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

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

Теперь вы также хотите перенести изменения на old-dot-net , вы измените на old-dot-net и извлеките из net-dot-net :

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

Это создаст новую голову в old-dot -net :

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

, поскольку набор изменений [x] имеет [b] в качестве родительского набора изменений. Ты сейчас иметь несколько головок и должны объединяться, чтобы уменьшить количество головы. Путем слияния вы создаете новую ревизию, которая является вашим способом говоря, «вот как должны сочетаться [x] и [d] ». Если [x] набор изменений касается только кода, который также не затрагивается в [c] и [d] , тогда слияние должно работать. В противном случае вам представят с инструментом слияния и должны разрешить конфликт. Вы совершаете объединить как chageset [e] :

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

Готово - теперь вы добавили изменение [x] в ваш код, совместимый с .Net 2.0.

Вы повторяете это каждый раз, когда происходило изменение в new-dot-net . Допустим, добавлены дополнительные функции:

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

После их добавления в old-dot-net вы получите

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

И теперь вы объединяете [e] и [z ] :

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

Важные части, о которых следует помнить, следующие:

• внесение любых новых функций в new-dot-net .
• pull изменения в old-dot-net
• никогда не вставляйте из old-dot-net в new-dot-net .

Если вы в какой-то момент обнаружите, что изменение в new-dot-net не необходимо в old-dot-net , тогда вам все равно нужно вытащить его и объединить Это. Но затем вы выполните фиктивное слияние . Если головы [w] и [g] , и вы хотите сохранить [g] , затем выполните

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

Уловка состоит в том, чтобы выполнить слияние, не заботясь о результатах, затем отмените все изменения и зафиксируйте неизмененную рабочую копию как слияние. Таким образом вы сообщаете миру, что "комбинация [w] и [g] is [g] ", то есть вы отбрасываете изменения в [w] . Новое изменения, сделанные в new-dot-net после [w] , затем могут быть объединены как нормально.