Compatibilité entre les versions 32 bits et 64 bits d’Office 2010

Résumé : Pour les clients qui travaillent avec 2 Go de données ou plus, Microsoft Office 2010 est désormais disponible en version 64 bits. Cet article traite des problèmes liés à la compatibilité de la version 32 bits avec la nouvelle version 64 bits et les applications Office 32 bits héritées, ainsi que des solutions disponibles. (7 pages imprimées)

Dernière modification : vendredi 24 avril 2015

S’applique à : Excel 2010 | Office 2007 | Office 2010 | Open XML | PowerPoint 2010 | SharePoint Server 2010 | VBA | Visual Basic for Applications 7.0 (VBA 7.0) | Word 2010

Dans cet article
Présentation des versions 32 bits et 64 bits de Microsoft Office 2010
Comparaison des systèmes 32 bits et 64 bits
Présentation de la base de code VBA 7
Compatibilité des contrôles ActiveX et des compléments COM
Compatibilité des interfaces de programmation d’applications
Utilisation d’attributs de compilation conditionnelle
Forum aux Questions
Conclusion
Ressources supplémentaires

Applies to:   Microsoft Office 2010

Date de publication :   mars 2010

Auteur :   Microsoft Corporation

Sommaire

• Présentation des versions 32 bits et 64 bits de Microsoft Office 2010

• Comparaison des systèmes 32 bits et 64 bits

• Présentation de la base de code VBA 7

• Compatibilité des contrôles ActiveX et des compléments COM

• Compatibilité des interfaces de programmation d’applications

• Utilisation d’attributs de compilation conditionnelle

• Forum aux Questions

• Conclusion

• Ressources supplémentaires

Présentation des versions 32 bits et 64 bits de Microsoft Office 2010

Le système Microsoft Office 2010 est disponible dans des versions 32 bits et 64 bits. La version 64 bits vous permet de travailler avec des jeux de données beaucoup plus volumineux, ce qui est utile en particulier lors de l’utilisation de très grands nombres dans Microsoft Excel 2010.

Avec l’introduction de la nouvelle version 64 bits de Microsoft Office 2010, une nouvelle version de Microsoft Visual Basic pour Applications (VBA), nommée Microsoft Visual Basic pour Applications 7.0 (VBA 7), a été publiée pour être utilisée avec les applications 32 bits et 64 bits. Il est important de noter que les modifications abordées dans cet article s’appliquent uniquement à la version 64 bits de Microsoft Office 2010. L’utilisation de la version 32 bits d’Office 2010 vous permet d’utiliser des solutions créées dans des versions précédentes de Microsoft Office sans modification.

Dans VBA 7, vous devez mettre à jour les instructions d’API (Application Programming Interface) Windows existantes (instructions Declare) pour qu’elles fonctionnent avec la version 64 bits. En outre, vous devez mettre à jour les pointeurs d’adresses et les handles de fenêtres d’affichage dans les types définis par l’utilisateur qui sont utilisés par ces instructions. Cet aspect est abordé plus en détail dans cet article, de même que les problèmes de compatibilité entre les versions 32 bits et 64 bits d’Office 2010 et les solutions suggérées.

Comparaison des systèmes 32 bits et 64 bits

Les applications créées avec la version 64 bits d’Office 2010 peuvent faire référence à des espaces d’adresses plus grands, et offrent donc l’opportunité d’utiliser davantage de mémoire physique qu’auparavant, ce qui permet de réduire la charge liée au déplacement de données dans et en dehors de la mémoire physique.

Vous pouvez non seulement faire référence à des emplacements spécifiques (également appelés pointeurs) dans la mémoire physique utilisés par une application pour stocker des données ou des instructions de programmation, mais également utiliser des adresses pour faire référence à des identificateurs de fenêtres d’affichage (appelés handles). La taille (en octets) du pointeur ou du handle varie selon que vous utilisez un système 32 bits ou 64 bits.

Il existe deux problèmes fondamentaux lors de l’exécution de solutions existantes avec la version 64 bits d’Office 2010 :

• Les processus 64 bits natifs dans Office 2010 ne peuvent pas charger de binaires 32 bits. Il s’agit d’un problème courant en cas de présence de compléments et de contrôles Microsoft ActiveX existants.

• VBA n’offrait auparavant aucun type de données de pointeur ; c’est pourquoi les développeurs utilisaient des variables 32 bits pour stocker des pointeurs et des handles. Ces variables tronquent désormais les valeurs 64 bits retournées par les appels d’API lors de l’utilisation d’instructions Declare.

Présentation de la base de code VBA 7

VBA 7 est une nouvelle base de code qui remplace la version antérieure de VBA. VBA 7 existe pour les version 32 bits et 64 bits d’Office 2010. Il procure deux constantes de compilation conditionnelle : VBA7 et Win64. La constante VBA7 aide à garantir la compatibilité descendante de votre code en vérifiant si votre application utilise VBA 7 ou la version précédente de VBA. La constante Win64 permet de vérifier si le code s’exécute comme 32 bits ou 64 bits. Ces deux constantes de compilation sont illustrées plus loin dans cet article.

Malgré quelques exceptions indiquées ailleurs dans cet article, les macros dans un document (classeur et présentations également) qui fonctionnaient avec la version 32 bits de l’application fonctionneront après le chargement du document dans la version 64 bits de la même application.

Compatibilité des contrôles ActiveX et des compléments COM

Les contrôles ActiveX 32 bits existants, qu’ils soient fournis par des tierces parties ou par Microsoft, ne sont pas compatibles avec la version 64 bits de Office 2010. Pour les contrôles ActiveX et les objets COM, il existe trois solutions possibles :

• Si vous avez le code source, vous pouvez générer une version 64 bits vous-même.

• Vous pouvez contacter le fournisseur afin d’obtenir une version mise à jour.

• Vous pouvez tenter de trouver une solution alternative.

Les processus 64 bits natifs dans Office 2010 ne peuvent pas charger de fichiers binaires 32 bits. Ceci inclut les contrôles courants de MSComCtl (TabStrip, Toolbar, StatusBar, ProgressBar, TreeView, ListViews, ImageList, Slider, ImageComboBox) et les contrôles de MSComCt2 (Animation, UpDown, MonthView, DateTimePicker, FlatScrollBar). Ces contrôles ont été installés par des versions précédentes de Microsoft Office et sont installés par Office 2010 32 bits. Une solution de remplacement doit être trouvée pour les solutions VBA Microsoft Office existantes qui utilisent ces contrôles lorsque le code est migré vers Office 2010 64 bits. Office 2010 64 bits ne fournit pas toutes les versions 64 bits des contrôles courants.

Compatibilité des interfaces de programmation d’applications

La combinaison de VBA et de bibliothèques de types met à votre disposition de nombreuses fonctionnalités pour la création d’applications Microsoft Office. Néanmoins, il est parfois nécessaire de communiquer directement avec le système d’exploitation de l’ordinateur et avec d’autres composants, par exemple lorsque vous gérez de la mémoire ou des processus, lors de l’utilisation d’éléments d’interface utilisateur telles que fenêtre et contrôles, ou lors de la modification du Registre de Windows. Dans ces scénarios, la meilleure option consiste à utiliser l’une des fonctions externes incorporées dans les fichiers DLL (Dynamic Linked Library). Pour cela, vous devez dans VBA effectuer des appels d’API à l’aide d’instructions Declare.

Les instructions Declare ressemblent à ce qui suit, selon que vous appelez une sous-routine (qui n’a aucune valeur de retour) ou une fonction (qui a une valeur de retour).

    Public/Private Declare Sub SubName Lib "LibName" Alias "AliasName" (argument list)
    Public/Private Declare Function FunctionName Lib "Libname" alias "aliasname" (argument list) As Type

La fonction SubName ou FunctionName est remplacée par le nom de la procédure dans le fichier DLL et représente le nom utilisé lorsque la procédure est appelée à partir de code VBA. Vous pouvez également spécifier un argument AliasName pour le nom de la procédure, si vous le souhaitez. Le nom du fichier DLL qui contient la procédure appelée suit le mot clé Lib. Pour finir, la liste d’arguments contient les paramètres et types de données qui doivent être passés à la procédure.

L’instruction Declare suivante ouvre un subkey dans le Registre de Windows et remplace sa valeur.

    Declare Function RegOpenKeyA Lib "advapi32.dll" (ByVal Key As Long, ByVal SubKey As String, NewKey As Long) As Long

L’entrée Windows.h (handle de fenêtre) pour la fonction RegOpenKeyA est la suivante :

    LONG RegOpenKeyA ( HKEY hKey, LPCSTR lpSubKey, HKEY *phkResult );

En Microsoft Visual C et Microsoft Visual C++, l’exemple précédent est compilé correctement en 32 bits et 64 bits. Cela est dû au fait que HKEY est défini comme un pointeur, dont la taille reflète la taille mémoire de la plateforme sur laquelle le code est compilé.

Dans les versions précédentes de VBA, il n’existait aucun type de données de pointeur spécifique ; le type de données Long était par conséquent toujours utilisé. Le type de données Long étant toujours 32 bits, cela provoque un échec en cas d’utilisation sur un système avec une mémoire 64 bits car les 32 bits supérieurs peuvent être tronqués ou peuvent remplacer d’autres adresses mémoire. L’une ou l’autre de ces situations peut provoquer un comportement inattendu ou un blocage système.

Pour résoudre ce problème, VBA contient désormais un type de données pointeur réel : LongPtr. Ce nouveau type de données vous permet d’écrire l’instruction Declare d’origine correctement comme suit :

    Declare PtrSafe Function RegOpenKeyA Lib "advapire32.dll" (ByVal hKey as LongPtr, ByVal lpSubKey As String, phkResult As LongPtr) As Long

Ce type de données et le nouvel attribut PtrSafe vous permettent d’utiliser cette instruction Declare sur des systèmes 32 bits ou 64 bits. L’attribut PtrSafe indique au compilateur VBA que l’instruction Declare cible la version 64 bits d’Office 2010. Sans cet attribut, l’utilisation de l’instruction Declare sur un système 64 bits génère une erreur au moment de la compilation. Notez que l’attribut PtrSafe est facultatif dans la version 32 bits d’Office 2010. Ceci permet aux instructions Declare existantes de fonctionner comme elles l’ont toujours fait.

Le tableau suivant fournit des informations supplémentaires sur les nouveaux qualificateur et type de données dont nous venons de discuter et sur un autre type de données, deux opérateurs de conversion et trois fonctions.

L’exemple suivant montre comment utiliser certains de ces éléments dans une instruction Declare.

    Declare PtrSafe Function RegOpenKeyA Lib "advapi32.dll" (ByVal Key As LongPtr, ByVal SubKey As String, NewKey As LongPtr) As Long

Notez que les instructions Declare sans attribut PtrSafe sont considérées comme non compatibles avec la version 64 bits d’Office 2010.

Comme nous l’avons vu plus haut, il existe deux nouvelles constantes de compilation conditionnelle : VBA7 et Win64. Pour garantir la compatibilité descendante avec les versions précédentes de Microsoft Office, la constante VBA7 est utilisée (il s’agit du cas le plus courant) afin d’empêcher le code 64 bits de s’exécuter dans la version antérieure de Microsoft Office. Pour le code qui diffère entre la version 32 bits et la version 64 bits, tel que l’appel d’une API mathématique qui utilise LongLong pour sa version 64 bits et Long pour sa version 32 bits, la constante Win64 est utilisée. Le code suivant illustre l’utilisation de ces deux constantes.

    #if Win64 then
       Declare PtrSafe Function MyMathFunc Lib "User32" (ByVal N As LongLong) As LongLong
    #else
       Declare Function MyMathFunc Lib "User32" (ByVal N As Long) As Long
    #end if
    #if VBA7 then
       Declare PtrSafe Sub MessageBeep Lib "User32" (ByVal N AS Long)
    #else
       Declare Sub MessageBeep Lib "User32" (ByVal N AS Long)
    #end if

Pour résumer, si vous écrivez du code 64 bits et que prévoyez de l’utiliser dans des versions précédentes de Microsoft Office, il faut utiliser la constante de compilation conditionnelle VBA7. En revanche, si vous écrivez du code 32 bits dans Office 2010, ce code fonctionne tel que dans les versions précédentes d’Microsoft Office sans la constante de compilation. Si vous souhaitez être sûr d’utiliser des instructions 32 bits pour les versions 32 bits et des instructions 64 bits pour les versions 64 bits, la meilleure solution consiste à utiliser la constante de compilation conditionnelle Win64.

Utilisation d’attributs de compilation conditionnelle

Le code suivant est un exemple de code VBA hérité qui doit être mis à jour. Notez les types de données dans le code hérité qui doivent être mis à jour de façon à utiliser LongPtr car ils font référence à des handles ou des pointeurs.

Code VBA hérité

    Declare Function SHBrowseForFolder Lib "shell32.dll" _
      Alias "SHBrowseForFolderA" (lpBrowseInfo As BROWSEINFO) As Long
      
    Public Type BROWSEINFO
      hOwner As Long
      pidlRoot As Long
      pszDisplayName As String
      lpszTitle As String
      ulFlags As Long
      lpfn As Long
      lParam As Long
      iImage As Long
    End Type

Nouveau code VBA

    #if VBA7 then    ' VBA7 
    Declare PtrSafe Function SHBrowseForFolder Lib "shell32.dll" _
      Alias "SHBrowseForFolderA" (lpBrowseInfo As BROWSEINFO) As Long
    
    Public Type BROWSEINFO
      hOwner As LongPtr
      pidlRoot As Long
      pszDisplayName As String
      lpszTitle As String
      ulFlags As Long
      lpfn As LongPtr
      lParam As LongPtr
      iImage As Long
    End Type
     
    #else    ' Downlevel when using previous version of VBA7
    
    Declare Function SHBrowseForFolder Lib "shell32.dll" _
      Alias "SHBrowseForFolderA" (lpBrowseInfo As BROWSEINFO) As Long
    
    Public Type BROWSEINFO
      hOwner As Long
      pidlRoot As Long
      pszDisplayName As String
      lpszTitle As String
      ulFlags As Long
      lpfn As Long
      lParam As Long
      iImage As Long
    End Type
     
    #end if
    Sub TestSHBrowseForFolder ()
        Dim bInfo As BROWSEINFO
        Dim pidList As Long
    
        bInfo.pidlRoot = 0&
        bInfo.ulFlags = &H1
        pidList = SHBrowseForFolder(bInfo)
    End Sub

Forum aux Questions

Les questions ci-dessous sont celles fréquemment posées concernant les versions 32 bits et 64 bits de Microsoft Office.

• À quel moment dois-je utiliser la version 64 bits de Microsoft Office ?
  Cette décision dépend de l’application hôte que vous utilisez (Excel, Word, etc.). Par exemple, Excel peut gérer des feuilles de calcul beaucoup plus volumineuses avec la version 64 bits de Microsoft Office.

• Puis-je installer les versions 64 bits et 32 bits de Microsoft Office côte à côte ?
  Non.

• À quel moment dois-je convertir les paramètres Long en LongPtr ?
  Vous devez consulter la documentation relative à l’API Windows sur Microsoft Developers Network pour la fonction à appeler. Les poignées et les pointeurs doivent être convertis en LongPtr. Par exemple, la documentation relative à RegOpenKeyA fournit la signature suivante :

  LONG WINAPI RegOpenKeyEx(
    __in        HKEY hKey,
    __in_opt    LPCTSTR lpSubKey,
    __reserved  DWORD ulOptions,
    __in        REGSAM samDesired,
    __out       PHKEY phkResult
  );
  

  Les paramètres sont définis de la façon suivante :

  Paramètre	Description
  hKey [in]	Poignée permettant d’ouvrir une clé de Registre.
  lpSubKey [in, facultatif]	Nom de la sous-clé de Registre à ouvrir.
  ulOptions	Ce paramètre est réservé et doit être égal à zéro.
  samDesired [in]	Masque qui spécifie les droits d’accès souhaités à la clé.
  phkResult [out]	Pointeur vers une variable qui reçoit une poignée vers la clé ouverte.

  Dans Win32API_PtrSafe.txt, l’instruction Declare est définie de la façon suivante :

  Declare PtrSafe Function RegOpenKeyEx Lib "advapi32.dll" Alias "RegOpenKeyExA" (ByVal hKey As LongPtr, ByVal lpSubKey As String, ByVal ulOptions As Long, ByVal samDesired As Long, phkResult As LongPtr) As Long
  

• Dois-je convertir des pointeurs et des poignées en structures ?
  Oui. Voir le type MSG dans Win32API_PtrSafe.txt :

  Type MSG
      hwnd As LongPtr
      message As Long
      wParam As LongPtr
      lParam As LongPtr
      time As Long
      pt As POINTAPI
  End TypeF
  

• À quel moment dois-je utiliser strptr, varpt et objptr ?
  Vous devez utiliser ces fonctions pour extraire des pointeurs vers des chaînes, des variables et des objets, respectivement. Dans la version 64 bits de Microsoft Office, ces fonctions renvoient un paramètre LongPtr 64 bits, qui peut être transmis aux instructions Declare. L’utilisation de ces fonctions ne diffère pas par rapport aux versions précédentes de VBA. La seule différence réside dans le fait qu’elles renvoient désormais un paramètre LongPtr.

Conclusion

L’ajout d’une version 64 bits d’Office 2010 vous permet de manipuler davantage de données afin d’accroître les fonctionnalités. Lors de l’écriture de code 32 bits, vous pouvez utiliser la version 64 bits de Microsoft Office sans modification. En revanche, lors de l’écriture de code 64 bits, vous devez faire en sorte que votre code contienne des mots clés et des constantes de compilation conditionnelle spécifiques afin de garantir sa compatibilité descendante avec les versions antérieures de Microsoft Office et d’être certain que le code correct est exécuté si vous mélangez du code 32 bits et 64 bits.

Ressources supplémentaires

Pour plus d’informations sur les instructions Declare, voir les ressources suivantes :

• Anatomy of a Declare Statement