Comment mettre à jour des fichiers d'application en utilisant des correctifs?

Question

Je suis pas intéressé par une solution de mise à jour automatique, telle que ClickOnce ou le bloc MS Updater. Pour ceux qui ressentent l'envie de se demander pourquoi: je les utilise déjà et il n'y a rien de mal avec eux, je voudrais juste apprendre des alternatives efficaces.

Je voudrais publier patches = petites différences qui vont modifier les fichiers existants du déploiement avec le plus petit delta possible. Non seulement le code doit être corrigé, mais aussi les fichiers de ressources. La correction du code en cours peut être effectuée en conservant deux copies synchronisées distinctes du déploiement (aucune modification à la volée de l'exécutable en cours d'exécution n'est requise).

L'application elle-même peut être déployé xcopy (pour éviter automatiquement corriger MSI les fichiers modifiés ou rupture des signatures ClickOnce).

• Je voudrais savoir comment gérer les différentes versions de patches (par exemple, il y a un patch émis qui corrige une erreur et plus tard un autre patch qui corrige une autre erreur (dans le même fichier) - les utilisateurs peuvent avoir une combinaison de ceux-ci et il vient un troisième patch - dans les fichiers texte, cela peut être facile à mettre en œuvre, mais qu'en est-il des fichiers exécutables? (code Win32 natif vs .NET, une différence?)

• Si le premier problème est trop difficile à résoudre ou insoluble pour les exécutables, je voudrais au moins savoir s'il existe une solution qui implémente un simple patch avec des révisions en série - pour installer la révision 5, l'utilisateur doit avoir toutes les révisions précédentes installées pour garantir la validité du déploiement.

• Les patchs peuvent être émis sous forme de fichiers téléchargeables à partir d'un site Web - aucune fonctionnalité auto-patcher directement à partir d'une application en cours d'exécution est nécessaire.

Existe-t-il des solutions existantes pour y parvenir?

NOTE: Il y a quelques questions sur SO qui peuvent sembler les doublons, mais aucun avec une bonne réponse.

Cette question concerne la plate-forme Windows, de préférence .NET.

Jusqu'à présent, wyUpdate semble correspondre le mieux ce problème. Toujours intéressé par les alternatives.

Answer 1

Vous ne serez pas en mesure de créer un correctif binaire qui peut appliquer à plusieurs versions du programme, de sorte que le scénario suivant ne sera pas possible:

 org+p1 
    / \ 
    + p1  +p2 <-- note, p2 is the same patch both places 
/  \ 
original  org+p1+p2 
    \  /
    + p2  +p1 <-- ie. the p2 on this line is the same as the one above 
    \ /
     org+p2 

Vous à la place que ce scénario:

 org v.2 
    / \ 
    +p1  +p4 <-- note, different patches now 
/  \ 
org v.1  org v.4 
    \  /
    +p2  +p3 
    \ /
     org v.3 

vous devriez facilement voir la complexité de cela devient si vous voulez permettre à vos utilisateurs de cherrypick les correctifs qu'ils souhaitent appliquer. Oui, cela peut être fait avec des fichiers texte, après tout, c'est comme ça que la branche et la fusion fonctionnent avec la plupart des outils de contrôle de source, mais ils fonctionnent sur la base que vous pouvez insérer et supprimer des fichiers sans compromettre le reste du fichier. ne fonctionne pas avec un exécutable.

Remarque: Un cas particulier est celui des correctifs qui remplacent les octets, mais n'insèrent ou ne suppriment aucun élément du fichier.Tant que plusieurs de ces correctifs ne se chevauchent pas, il serait possible de sélectionner celles que vous souhaitez appliquer. Cependant, ces patchs sont très rares.

Vous devriez, comme vous l'avez fait allusion dans votre question, travailler avec une chronologie série, peut-être avec des correctifs simples aux versions existantes, de sorte que vous pourriez avoir cette place:

         +-- most up to date version 
             |    
             v 
org v.1   org v.3    org v.4 
    \   /  \   /
    +p1  +p2  +p3  +p4 
    \  /   \  /
     org v.2    org v.4 
     \ 
     +p1.1 
     \ 
      org v.2 hotfix 1 

Comme pour le code réel, je avoir une implémentation diff/patch, mais c'est probablement loin d'être optimal. Il prend actuellement beaucoup de temps pour produire les fichiers de correctif pour tout fichier de taille. Les correctifs sont assez petits, mais j'ose dire que d'autres algorithmes produiront de meilleurs correctifs. Des exemples de tests avec bsdiff and bspatch produisent des patchs plus petits. Toutefois, le code est here si vous voulez jouer avec. Il fait partie d'une bibliothèque de classes plus grande et je ne me souviens pas de la quantité de ressources (le reste de la bibliothèque) dont vous avez besoin pour compiler uniquement les classes de correctifs binaires, mais tout est là. La classe que vous souhaitez utiliser est la classe Delta2.