Je ne veux pas dire que cette question soit un appât à la flamme, mais j'utiliserai Microsoft et leur API win32 comme exemple d'API héritée. Maintenant, ce que je me demande, c'est que Microsoft consacre beaucoup d'argent et d'énergie à la maintenance de son API héritée, y compris tous les «pépins/bogues/solutions de contournement» nécessaires pour que l'API fonctionne de la même manière. Maintenant, je suis conscient que dans Windows 7, ils fournissent un moyen pour le client d'exécuter leur application dans une machine virtuelle "Windows XP" qui serait un tel moyen pour eux de commencer à nettoyer leur API Win32 parce qu'ils pourraient alors pousser tous l'application dans la machine virtuelle "Windows XP". Maintenant, ce que je me demande, est-il possible de virtualiser une API héritée de telle sorte qu'un client/programme puisse toujours y accéder et l'utiliser, tout en profitant de la nouvelle version/API? Parce que ce que je comprends, si l'application est exécuté dans le « Windows XP » VM, il ne sera pas en mesure d'accéder à la nouvelle API/fonctionnalité de Windows 7.Virtualisation de l'API héritée et coexistence avec une API plus moderne?
Répondre
Ce qui me laisse perplexe au sujet de cette question quand il arrive est que Windows a fait depuis NT est sorti dans les années nonante. C'est ainsi que NT exécute les programmes DOS et Win16, et ce qu'il a toujours fait. La couche de virtualisation NTVDM exécute des applications 16 bits sous Win32 avec très peu de prise en charge spéciale du système d'exploitation principal. Ceci est juste un exemple - un autre est WINE, qui, si je comprends bien, fait un travail assez raisonnable d'exécuter des applications Windows sur un ensemble d'API qui est très différent de celui de Windows. Donc c'est définitivement possible.
La question plus pertinente serait la raison pour laquelle Microsoft considérerait. Pour que vous pensiez qu'il est nécessaire, vous devez penser à deux choses. 1) Il y a quelque chose de mieux pour remplacer l'API Win32 avec et 2) Maintenir l'API Win32 est un fardeau.
Les deux sont discutables. Dans le cas des fonctions du noyau, telles que l'accès au matériel et la synchronisation et la création de threads, de processus et de mémoire, l'API Win32 fait un très bon travail, et est finalement assez proche de ce que fait réellement le noyau. Si vous pensez qu'il existe une meilleure API, cela signifie qu'il existe également un meilleur noyau. Personnellement, je ne pense pas que NT doit être remplacé dès maintenant. Pour les graphiques et les fenêtrages, admirablement gdi32 est un peu long dans la dent. Mais Microsoft a résolu ce problème en construisant WPF à ses côtés. Cela entraîne alors la question du fardeau. Bien sûr, il y a deux API à maintenir, mais si vous virtualisiez GDI au dessus de WPF, vous auriez quand même besoin de maintenir les deux, donc il n'y a aucun avantage. L'avantage d'exécuter les deux en parallèle est que GDI existe déjà et est déjà testé. Tout ce que vous avez à faire est de corriger le bug occasionnel, alors qu'une nouvelle couche de virtualisation devrait être écrite et testée à nouveau, ce qui prend du temps pour améliorer WPF.
En termes de maintien de compatibilité, ce n'est pas aussi lourd que cela en a l'air. C'est principalement une question de test - vous devez tester que le comportement de l'API ne change pas, mais encore une fois - ces tests ont déjà été écrits, donc ce n'est pas vraiment un travail supplémentaire. Donc, pour répondre à une question avec une question, pourquoi s'embêteraient-ils?
Ceci est une question intéressante, au moins pour moi, voici certaines de mes pensées.
Votre compréhension est correcte, une application en cours d'exécution dans la machine virtuelle XP n'a accès aux API Win32 fournies par XP dans la machine virtuelle. L'une des nombreuses façons que je l'ai vu l'approche de Microsoft pour améliorer les API spécifiques est de créer de nouvelles fonctions avec la fonctionnalité améliorée/fixe et le nom de la nouvelle fonction append Ex et même ExEx au nom d'origine, par exemple
GetVersion
GetVersionEx
Pour les fonctions qui acceptent les pointeurs vers les structures, les structures sont «versionnées» en utilisant la taille de la structure pour déterminer la fonctionnalité requise, donc le code plus ancien passerait une taille précédente de la structure tandis que le nouveau code passerait dans la plus grande La structure et l'API fonctionnent en conséquence. Le problème est devenu que ce ne sont plus seulement les différences dans le fonctionnement d'une API, mais plus le fonctionnement du système d'exploitation et les structures internes qui ont des changements significatifs que le code peut être mal écrit est effectivement brisé.
Quant à votre question réelle, je pense que ce serait assez difficile. Même si on pensait que le système d'exploitation ajusterait le code basé sur une version de système d'exploitation cible dans l'en-tête PE de l'exécutable, que se passerait-il si une nouvelle DLL était chargée dans le processus qui ciblait le dernier système d'exploitation? gérer cela lorsque le code est en cours d'exécution? À mon humble avis, je pense que ce serait très difficile, on se frotterait avec des pièges qui finiraient par échouer.
Bien sûr, c'est juste mes pensées premières sur le sujet donc je pourrais être à 100% faux et il y a une approche simple qui n'a tout simplement pas venu à l'esprit.
Bien sûr, .NET est une couche API qui masque Win32. –
Homme J'aimerais pouvoir accepter les deux réponses parce qu'elles ont toutes deux répondu à ma question de manière différente et excellente! – Pharaun