# VBA & MS Office automation

A series of 10 article(s), in reading order.

<!--
  canonical-url: https://www.avonture.be/fr/blog/vba-excel-ribbon
  published:     2023-12-10
  This is a static plain-Markdown mirror generated at build time.
  Visit the canonical URL above for the fully rendered page, with images and interactive components.
-->

# MS Office - Comment créer un ruban dans Excel

> Guide pas à pas pour créer un ruban Excel personnalisé en VBA. Utilisez XML et VBA pour ajouter vos propres onglets, groupes, boutons et fonctionnalités à vos classeurs Excel.

---
![MS Office - Comment créer un ruban dans Excel](/img/v2/ribbon.webp)

**TL;DR**

Cet article montre comment construire un ruban Excel personnalisé avec l'outil gratuit `CustomOfficeUIEditor` et du XML écrit à la main (le manifeste `customUI14.xml`) : définir des onglets, des groupes et des contrôles comme des boutons ou des zones de saisie, relier leurs événements `onAction`/`onChange` à des subroutines VBA de callback, et trouver les identifiants d'icônes standard `imageMso` à utiliser sur les boutons.

Dans cet article, nous allons apprendre à créer un ruban (c'est-à-dire une barre d'outils) dans Microsoft Excel.

Nous allons créer notre ruban personnalisé pour un fichier Excel et l'enregistrer dans le fichier, afin que nos utilisateurs disposent d'une interface agréable et intuitive pour travailler avec notre feuille de calcul.

*Un ruban n'est utile que si ses boutons font quelque chose d'intéressant. Pour un exemple concret, [MS Excel - Se connecter à une base de données SQL Server, exécuter une query et récupérer les résultats](/blog/vba-excel-sql-server-part-2) vous donne le VBA derrière un bouton « Rafraîchir les données ».*

## Ce que nous allons construire {#what-were-going-to-build}

Voici le résultat final : notre propre onglet, dans Excel, avec un bouton et un champ de saisie.

![Smiley\_and\_edit](./images/Smiley_and_edit.webp)

Le bouton est relié à une subroutine VBA : cliquer dessus exécute votre code.

![Button clicked](./images/Button_clicked.webp)

L'ensemble tient dans une quinzaine de lignes de XML stockées dans le classeur. Quiconque ouvre votre fichier `.xlsm` obtient le ruban ; il n'y a rien à installer sur sa machine.

## Pourquoi ça fonctionne {#why-it-works}

* Un fichier `.xlsx` / `.xlsm` n'est pas un blob binaire : c'est une archive ZIP contenant des fichiers et des dossiers. Vous pouvez en ouvrir un avec 7-Zip et regarder ce qu'il y a dedans.
* Ajouter un ruban revient à ajouter un fichier à cette archive : un manifeste appelé `customUI14.xml`, qui décrit en XML les onglets, les groupes et les contrôles.
* Quand MS Office ouvre le classeur, il lit ce manifeste, dessine le ruban et, à chaque clic, appelle la subroutine VBA nommée dans l'attribut `onAction` du contrôle. Votre macro et votre interface sont donc stockées dans un seul et même fichier.

## Téléchargez l'éditeur gratuitement {#download-the-editor-for-free}

Pour pouvoir créer « facilement » un ruban dans MS Office *(dans une interface qui n'est pas WYSIWYG)*, j'utilise un outil très ancien appelé `CustomOfficeUIEditor`. *Jusqu'ici, je n'ai trouvé aucun autre outil gratuit pour faire ça.*

L'outil peut être téléchargé depuis <https://bettersolutions.com/vba/ribbon/custom-ui-editor-download.htm>.

`CustomOfficeUIEditor` est un outil externe (en dehors de MS Office) qui peut ouvrir un fichier Office et y ajouter les fichiers nécessaires à la création d'un ruban. Il est possible de le faire sans éditeur, par exemple avec un logiciel comme 7-Zip, puisqu'un fichier `.xlsx` / `.xlsm` est une archive avec des fichiers et des dossiers.

Pour cet exercice, extrayez tous les fichiers et dossiers dans votre dossier `C:\tmp\ribbon` (créez-le).

## Créez un fichier vide {#create-an-empty-file}

Comme support pour cet article, créez un nouveau fichier vide dans Excel, appelé `Ribbon.xlsm`, dans votre dossier `C:\tmp\ribbon` (ou ailleurs).

![Excel Ribbon.xlsm](./images/Excel_empty_file.webp)

> **Créez juste un fichier vide:**
>
> Pour l'instant, rien d'autre à faire que Fichier - Nouveau - Enregistrer sous - Type de fichier - Classeur Excel (prenant en charge les macros).

## Ajoutez un ruban dans MS Office {#add-a-ribbon-in-ms-office}

L'outil `CustomOfficeUIEditor` n'est pas très convivial : vous devrez taper vous-même le XML du ruban. Ce XML est aussi appelé *le fichier manifeste*.

Par défaut, un document MS Office standard ne contient aucun ruban. Donc, quand vous ouvrez un tel fichier avec l'outil `CustomOfficeUIEditor`, vous obtenez un document vide.

*Outlook est l'exception : là, aucun XML n'est nécessaire puisque la boîte de dialogue intégrée `Personnaliser le ruban` peut héberger un bouton de macro, comme dans [Microsoft Outlook - VBA - Save emails as PDF](/blog/outlook-vba-pdf).*

Démarrez `CustomOfficeUIEditor` et ouvrez votre fichier `Ribbon.xlsm` :

![UI - Open Ribbon.xlsm](./images/UI_open.webp)

> **Fermez-le d'abord s'il est encore ouvert dans Excel:**
>
> Quand vous utilisez l'éditeur, le fichier ne peut pas être ouvert dans Excel en même temps ! Imaginez la situation suivante : le classeur est ouvert à la fois dans l'éditeur et dans Excel. Vous faites beaucoup de modifications dans Excel, passez à l'éditeur et changez le manifeste. En sauvegardant le fichier dans l'éditeur, vous perdrez toutes les modifications faites dans Excel donc... prudence.

La première fois, vous devrez ajouter un nouveau ruban : cliquez sur le menu `Insert` et sélectionnez `Office 2010 Custom UI Part`.

![Insert](./images/UI_Editor_Insert.webp)

Vous obtiendrez alors un écran comme celui-ci :

![Office 2010 Custom UI Part](./images/UI_Editor_Insert_UI14.webp)

Quand `customUI14.xml` est sélectionné (comme illustré ci-dessus), cliquez quelque part dans le volet de droite et commencez à écrire votre XML.

Maintenant, dans le volet de droite, copiez/collez simplement la source XML ci-dessous :

**customUI14.xml**

```xml
<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui">
    <ribbon>
        <tabs>
            <tab id="customTab" insertAfterMso="TabView" label="Tab">
                <group id="customGroup" label="Group">
                    <button
                        id="customButton"
                        label="Button"
                        imageMso="HappyFace"
                        size="large"
                        onAction="OnButtonClicked" />
                    <editBox
                        id="customEditBox"
                        label="Edit Box"
                        onChange="OnEditBoxTextChanged" />
                </group>
            </tab>
        </tabs>
    </ribbon>
</customUI>
```

![Manifest added](./images/UI_Editor_Added_UI14.webp)

Avant d'enregistrer votre fichier, n'oubliez pas de cliquer sur le bouton `Validate` : un contrôle est effectué pour vérifier la qualité du contenu.

![Check](./images/UI_Editor_Check.webp)

Le ruban étant correct, enregistrez le fichier et ouvrez-le dans Excel. Si tout se passe bien, vous obtiendrez ceci :

![Sample](./images/UI_Editor_Sample.webp)

> **Votre ruban a été créé:**
>
> Félicitations, vous avez ajouté un ruban à votre classeur. Ce n'était pas trop difficile, je crois.

## Sous le capot — le manifeste, balise par balise (sautez ceci si vous voulez juste un ruban) {#under-the-hood--the-manifest-tag-by-tag-skip-this-if-you-just-want-a-ribbon}

Il est temps de comprendre ce qui s'est passé...

### Le nœud racine customUI et le namespace {#the-root-customui-node-and-the-namespace}

**customUI14.xml**

```xml
<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui">
```

Le manifeste est un contenu XML et doit être valide. Vous devez définir votre contenu dans un nœud `<customUI>` (obligatoire) et spécifier l'attribut `xmlns` (pour `namespace`) (obligatoire).

Le fichier de `namespace` définit quels attributs existent, obligatoires ou non, pour chaque type de nœud. L'URL référencée est la `Document Type Definition` (aussi appelée *DTD*).

Par exemple, quand l'utilisateur cliquera sur le bouton de votre ruban, vous voudrez pouvoir capter le clic et démarrer une subroutine que vous avez codée en VBA. L'« événement on click » doit être défini dans l'attribut `onAction`, comme prévu par la DTD. *Microsoft maintient la documentation ici : <https://msdn.microsoft.com/en-us/library/dd909370(v=office.12).aspx>.*

Donc, si vous savez que l'attribut est `onAction`, vous pouvez ajouter votre propre subroutine en écrivant quelque chose comme `onAction="OnButtonClicked"`.

Le rôle de la DTD est de s'assurer que la syntaxe de votre manifeste est correcte ; l'attribut `xmlns="http://schemas.microsoft.com/office/2009/07/customui"` est donc bel et bien obligatoire.

### Définir le ruban {#define-the-ribbon}

Le ruban doit être défini dans le nœud `<ribbon>`, mais pas immédiatement, car un ruban est en fait toujours défini dans un onglet.

Ci-dessous, on voit le ruban standard d'Excel avec beaucoup d'onglets : `Fichier`, `Insertion`, `Mise en page`, `Formules`, `Données`, `Révision`, `Affichage`, ...

![Tabs](./images/Tabs.webp)

Chaque onglet propose des fonctionnalités (boutons, cases à cocher, ...). Pour l'onglet `Insertion`, nous avons d'abord un groupe de trois boutons dans un groupe appelé `Tableaux` :

![Insert - Group Tables](./images/Tab_Insert_Tables.webp)

Donc, pour un ruban, il faut :

1. Le définir dans un onglet (le vôtre ou un onglet existant)
2. Ajouter des fonctionnalités dans un ou plusieurs groupes (vos groupes ou des groupes existants)

Voici notre manifeste à présent, avec la définition du ruban.

**customUI14.xml**

```xml
<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui">
    <!-- highlight-next-line -->
    <ribbon>
        <!-- highlight-next-line -->
        <tabs>
            <!-- highlight-next-line -->
            <tab id="customTab" insertAfterMso="TabView" label="Tab">
                <!-- highlight-next-line -->
                <group id="customGroup" label="Group">
                    <!-- highlight-next-line -->
                    YOUR FEATURES HERE
                    <!-- highlight-next-line -->
                </group>
                <!-- highlight-next-line -->
            </tab>
            <!-- highlight-next-line -->
        </tabs>
        <!-- highlight-next-line -->
    </ribbon>
</customUI>
```

### Définir l'onglet {#define-the-tab}

Vous devez donner un identifiant à l'onglet (dans l'attribut `id`) : votre propre code pour un nouvel onglet ou l'id d'un onglet existant.

Les noms standard sont :

* `TabHome`
* `TabInsert`
* `TabPageLayoutExcel`
* `TabFormulas`
* `TabData`
* `TabReview`
* `TabView`
* `TabDeveloper`

Donc, si vous voulez ajouter un bouton à l'onglet Accueil, utilisez simplement `TabHome` comme valeur de `id`, par exemple :

**customUI14.xml**

```xml
<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui">
    <ribbon>
        <tabs>
            <!-- highlight-next-line -->
            <tab id="TabHome">
                <!-- highlight-next-line -->
                ADD A BUTTON TO TabHome
            <!-- highlight-next-line -->
            </tab>
        </tabs>
    </ribbon>
</customUI>
```

Le XML ci-dessous va, en une ligne :

1. Créer un nouvel onglet puisque l'id `customTab` n'est pas un id existant,
2. Placer le nouvel onglet après l'onglet `Affichage` existant (utilisez `insertBeforeMso` pour l'ajouter avant),
3. Et lui donner `Tab` comme libellé.

**customUI14.xml**

```xml
<tab id="customTab" insertAfterMso="TabView" label="Tab">
```

Voici notre onglet ajouté :

![Add\_new\_tab](./images/Add_new_tab.webp)

### Implémenter notre ruban {#implement-our-ribbon}

Dans la déclaration `<tab>`, vous devez définir au moins un `<group>`. Et ici aussi, vous devrez définir l'identifiant : un identifiant existant pour, par exemple, ajouter un bouton dans un groupe existant, ou un nouveau pour créer un nouveau groupe.

Le XML ci-dessous va :

1. Créer un nouveau groupe puisque l'id est nouveau (`customGroup`),
2. Et lui donner `Group` comme nom.

**customUI14.xml**

```xml
<group id="customGroup" label="Group">
```

Notre onglet avec son groupe :

![Just a group defined](./images/Group_is_required.webp)

Comme vous le voyez ci-dessus, ajouter un groupe ne suffit pas : vous devez définir quelles fonctionnalités (boutons, cases à cocher, ...) doivent être ajoutées dans le groupe.

### Ajouter des fonctionnalités {#add-features}

Le XML ci-dessous va ajouter deux choses : un bouton et une zone de saisie.

**customUI14.xml**

```xml
<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui">
    <ribbon>
        <tabs>
            <tab id="customTab" insertAfterMso="TabView" label="Tab">
                <group id="customGroup" label="Group">
                    <!-- highlight-next-line -->
                    <button
                    <!-- highlight-next-line -->
                    id="customButton"
                    <!-- highlight-next-line -->
                    label="Button"
                    <!-- highlight-next-line -->
                    imageMso="HappyFace"
                    <!-- highlight-next-line -->
                    size="large"
                    <!-- highlight-next-line -->
                    onAction="OnButtonClicked" />
                    <!-- highlight-next-line -->
                    <editBox
                    <!-- highlight-next-line -->
                    id="customEditBox"
                    <!-- highlight-next-line -->
                    label="Edit Box"
                    <!-- highlight-next-line -->
                    onChange="OnEditBoxTextChanged" />
                </group>
            </tab>
        </tabs>
    </ribbon>
</customUI>
```

Le XML ci-dessous va créer un bouton :

1. Avec un `id` initialisé à `customButton`,
2. Son libellé (le texte affiché sous le bouton) défini à `Button`,
3. Utilisant l'image standard `HappyFace` (`imageMso` est en effet la manière de réutiliser une image standard, tandis que `image` vous permet de définir la vôtre),
4. La taille du bouton sera `large` (un grand bouton),
5. L'action assignée sera la fonction VBA appelée `OnButtonClicked`.

**customUI14.xml**

```xml
<button
    id="customButton"
    label="Button"
    imageMso="HappyFace"
    size="large"
    onAction="OnButtonClicked" />
```

Ce qui donne ceci :

![Smiley](./images/Smiley.webp)

`OnButtonClicked` est le callback VBA : pour le faire fonctionner, ajoutez un module dans votre fichier Excel et créez une subroutine comme celle-ci :

```vbnet
Public Sub OnButtonClicked(control As IRibbonControl)
    MsgBox "You've clicked on the button", vbInformation
End Sub
```

Pour ce faire, dans MS Excel, appuyez sur `ALT`-`F11`, puis dans l'**Explorateur de projet**, faites un clic droit sur l'entrée **VBAProject (Ribbon.xlsm)** (1), sélectionnez **Insertion** (2) puis **Module** (3).

![Insert a module](./images/VBE_insert_module.webp)

Un `Module1` sera ajouté et, dans le volet de droite, copiez/collez le code donné ci-dessus puis enregistrez le fichier.

![Add code](./images/VBE_add_code.webp)

Maintenant, vous pouvez fermer la fenêtre *Microsoft Visual Basic for Application*, revenir à la fenêtre Excel habituelle et cliquer sur le bouton smiley : vous obtiendrez la boîte de message montrée dans la deuxième capture d'écran en haut de cet article.

Et nous pouvons ajouter d'autres fonctionnalités, comme une zone de saisie :

**customUI14.xml**

```xml
<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui">
    <ribbon>
        <tabs>
            <tab id="customTab" insertAfterMso="TabView" label="Tab">
                <group id="customGroup" label="Group">
                    <button
                        id="customButton"
                        label="Button"
                        imageMso="HappyFace"
                        size="large"
                        onAction="OnButtonClicked" />
                    <!-- highlight-next-line -->
                    <editBox
                    <!-- highlight-next-line -->
                    id="customEditBox"
                    <!-- highlight-next-line -->
                    label="Edit Box"
                    <!-- highlight-next-line -->
                    onChange="OnEditBoxTextChanged" />
                </group>
            </tab>
        </tabs>
    </ribbon>
</customUI>
```

Enregistrez, réouvrez le fichier, et votre onglet ressemble maintenant à la toute première capture d'écran de cet article.

La liste des propriétés dépend du type : pour un bouton, nous avons un attribut `onAction`, alors que c'est `onChange` pour un editBox.

## Liste des objets {#list-of-objects}

Comme défini de manière exhaustive dans le `namespace du ruban`, voici la liste des objets valides :

* `box`,
* `button`,
* `buttonGroup`,
* `checkBox`,
* `control`,
* `comboBox`,
* `dropDown`,
* `dynamicMenu`,
* `editBox`,
* `gallery`,
* `labelControl`,
* `menu`,
* `splitButton` et
* `toggleButton`

**Attention** : le XML est sensible à la casse, `editBox` est la seule syntaxe valide, `editbox` ou `EditBox` ne le sont pas.

Chaque objet a ses propres attributs, certains obligatoires, les autres optionnels.

## Trouver des images {#find-images}

En ajoutant un bouton par exemple, vous lui assignerez une image.

Vous utiliserez très probablement une image standard existante. C'est possible avec l'attribut `imageMso`, en indiquant à Office quelle image utiliser ; par exemple `AddFolderToFavorites` :

![Favorites](./images/Favorites.webp)

Le manifeste est celui-ci :

**customUI14.xml**

```xml
<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui">
    <ribbon>
        <tabs>
            <tab idMso="TabHome" visible="false" />
            <tab id="customTab" insertAfterMso="TabView" label="Tab">
                <group id="customGroup" label="Group">
                    <button
                        id="customButton"
                        label="Button"
                    <!-- highlight-next-line -->
                    imageMso="AddFolderToFavorites"
                    size="large"
                    onAction="OnButtonClicked" />
                </group>
            </tab>
        </tabs>
    </ribbon>
</customUI>
```

Mais ... **comment récupérer la liste des images ?**

Microsoft maintient des fichiers Excel avec la liste des IDs existants utilisables comme icônes dans notre ruban. Les Office Fluent User Interface Control Identifiers sont maintenus sur le [repository GitHub OfficeDev](https://github.com/OfficeDev/office-fluent-ui-command-identifiers) (versions actuelles pour toutes les éditions d'Office). Vous obtiendrez des fichiers Excel, un par application (Access, Excel, Outlook, ...).

Cela vous donnera la liste des IDs existants en texte brut, mais vous ne verrez pas les images associées.

Vous pouvez télécharger toutes les images (en PNG) pour MS Office depuis le [repository GitHub ImageMso](https://github.com/christianarielli/ImageMso) (8 899 icônes, avec un Add-In Excel intégré pour les parcourir).

## Assigner des callbacks {#assign-callbacks}

Ce terme signifie : quel code (du VBA dans ce cas) doit être déclenché quand un événement est levé.

Quand l'utilisateur clique sur un bouton du ruban, quelle subroutine doit être appelée ?

Le code XML ci-dessous assigne la subroutine `OnButtonClicked` à l'événement `onAction` du bouton.

**customUI14.xml**

```xml
<button
    id="customButton"
    label="Button"
    imageMso="AddFolderToFavorites"
    size="large"
    onAction="OnButtonClicked" />
```

Donc, si nous voulons capturer cet événement, nous devrons ajouter une subroutine publique dans notre fichier Excel. Cette subroutine peut être placée dans n'importe quel module, doit être publique et doit s'appeler `OnButtonClicked`.

Mais... selon les callbacks (click, change, toggle state, change, ...), la définition de la subroutine n'est pas la même.

Pour un bouton, le VBA ressemblera à ceci :

```vbnet
Public Sub OnButtonClicked(control As IRibbonControl)
    ' YOUR CODE
End Sub
```

Pour une zone de saisie et l'événement `onChange`, le callback est différent :

**customUI14.xml**

```xml
<editBox
    id="customEditBox"
    label="Edit Box"
    onChange="OnEditBoxTextChanged" />
```

```vbnet
Public Sub OnEditBoxTextChanged(control As IRibbonControl, sText As String)
    ' YOUR CODE
End Sub
```

La déclaration des callbacks se trouve sur le site officiel :
[How can I determine the correct signatures for each callback procedure?](https://docs.microsoft.com/en-us/previous-versions/office/developer/office-2007/aa722523\(v=office.12\)#how-can-i-determine-the-correct-signatures-for-each-callback-procedure). Faites attention aux colonnes `Signatures` ; vous devez chercher `VBA`.

## Conclusion {#conclusion}

Un classeur où il fallait auparavant *« ouvrir l'éditeur VBA, trouver la macro, l'exécuter »* a maintenant son propre onglet avec de vrais boutons ; et tout est stocké dans le fichier `.xlsm`, donc ça suit le classeur partout. Les deux choses à retenir : le manifeste est `customUI14.xml` dans l'archive, et chaque contrôle pointe vers une subroutine VBA publique via `onAction` (ou `onChange`).

Une fois votre ruban en place, une étape suivante fréquente consiste à alimenter un de ses contrôles (comme une liste déroulante) avec des données issues directement de votre feuille de calcul — voir [MS Office - Load dropdown from Excel's range](/blog/vba-excel-ribbon-load). Et pour donner à vos boutons quelque chose qui vaille le clic, [MS Excel - Connect to a SQL Server database](/blog/vba-excel-sql-server-part-2) est un bon endroit pour continuer.


---

<!--
  canonical-url: https://www.avonture.be/fr/blog/vba-excel-call-soap-webservice
  published:     2024-02-21
  This is a static plain-Markdown mirror generated at build time.
  Visit the canonical URL above for the fully rendered page, with images and interactive components.
-->

# MS Excel - Comment appeler un web service SOAP

> Maîtrisez l'appel de web services SOAP depuis MS Excel avec VBA. Récupérez le code et un tutoriel pas à pas pour valider des numéros de TVA avec le service VIES.

---
![MS Excel - Comment appeler un web service SOAP](/img/v2/excel.webp)

**TL;DR**

Cet article présente un squelette VBA pour appeler un web service SOAP depuis Excel, avec le service européen VIES de validation des numéros de TVA comme exemple concret : construction d'un fichier XML de requête avec des placeholders, envoi via `MSXML2.ServerXMLHTTP60`, puis ouverture de la réponse XML dans un nouveau classeur. Un équivalent Linux basé sur `curl` est également inclus pour comparaison.

Imaginez que vous deviez appeler un web service SOAP depuis Excel. Par exemple, pour valider un numéro de TVA qu'on vous a communiqué avant de lancer un traitement.

Vous allez appeler l'URL qui correspond au web service souhaité, mais il faudra aussi transmettre un certain nombre de paramètres au format XML pour que le service sache ce que vous voulez faire.

Dans ce billet, nous allons voir comment valider un numéro de TVA européen à l'aide du web service SOAP [VIES VAT number validation](https://ec.europa.eu/taxation_customs/vies/#/vat-validation).

Le code VBA présenté ici peut servir de squelette pour vos futurs développements.

*Ce même service VIES sert d'exemple fil rouge dans [Using Postman to play with API](/blog/postman), où la réponse XML est vérifiée nœud par nœud — une bonne façon de comprendre une réponse SOAP avant d'écrire le VBA qui la parse.*

Lorsqu'on appelle un service SOAP, il faut toujours préparer un message XML au préalable. Pour cela, nous créons un fichier .xml quelque part sur notre disque dur.

## Créer le message xml {#create-the-xml-message}

Créez le fichier `C:\temp\checkVat.xml` avec ce contenu. Ce message (contenu) est celui attendu par le web service VIES de validation de numéro de TVA. Dans le fichier, nous prévoyons deux placeholders pour nos variables : `%COUNTRY%` et `%VATNUMBER%`. Nous y reviendrons plus loin.

**C:\temp\checkVat.xml**

```xml
<?xml version="1.0" encoding="utf-8"?>
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
    <soapenv:Body>
        <urn:checkVat xmlns:urn="urn:ec.europa.eu:taxud:vies:services:checkVat:types">
            <urn:countryCode>%COUNTRY%</urn:countryCode>
            <urn:vatNumber>%VATNUMBER%</urn:vatNumber>
        </urn:checkVat>
    </soapenv:Body>
</soapenv:Envelope>
```

## Créer le classeur Excel {#create-the-excel-workbook}

Maintenant, procédez comme suit :

1. Créez un classeur Excel vide,
2. Appuyez sur `ALT`-`F11` pour ouvrir l'éditeur Visual Basic (aussi appelé `vbe`).
3. Créez un nouveau module :
   ![Créer un nouveau module](./images/insert_module.webp)
4. Copiez/collez-y le code VBA ci-dessous.
5. Vérifiez le chemin de la constante `InputXmlFile`. Assurez-vous qu'il correspond à l'endroit où vous avez enregistré votre fichier `.xml`.
6. Cliquez sur le menu `Tools` puis sélectionnez `References` et ajoutez une référence vers `Microsoft XML, v6.0`
   ![Tools - References](./images/tools_references.webp)
   ![Microsoft XML, v6.0](./images/microsoft_xml6.webp)
7. Enfin, placez le curseur n'importe où dans la sous-routine `run` et appuyez sur `F5` pour l'exécuter.
   ![Activer la sous-routine run](./images/sub_run.webp)
8. Après quelques secondes, un nouveau classeur sera créé avec la réponse du web service SOAP :
   ![Réponse SOAP](./images/soap_answer.webp)

```vbnet
Option Explicit

' URL to call
Const URL = "http://ec.europa.eu/taxation_customs/vies/services/checkVatService"

' XML to send to the web service method
Const InputXmlFile = "C:\temp\checkVat.xml"

' *************************************************************
'
' Entry point
'
'    - Call the web service checkVAT method
'    - Upload XML data (country and VAT number)
'    - Get XML response
'    - Open the response as a workbook
'
' *************************************************************
Sub run()

    Dim sData As String
    Dim sResponseFileName As String

    ' Get the input manifest
    sData = openCheckVatXml(InputXmlFile)

    ' Consume the web service and get a filename with the response
    If (sData = "") Then
        MsgBox "Failure, the " & InputXmlFile & " file didn't exist", vbExclamation + vbOKOnly
        Exit Sub
    End If

    sResponseFileName = consumeWebService(URL, sData)

    ' Open the response as a workbook
    Call Application.Workbooks.OpenXML(Filename:=sResponseFileName)

End Sub

' *************************************************************
'
' Open the checkVat.xml input and replace variables
'
' *************************************************************
Private Function openCheckVatXml(ByVal sFileName As String) As String

    Dim sData As String

    sData = readFile(sFileName)

    If (sData <> "") Then
        sData = Replace(sData, "%COUNTRY%", "BE")
        sData = Replace(sData, "%VATNUMBER%", "0403170701") ' ENGIE Electrabel Belgique
    End If

    openCheckVatXml = sData

End Function

' *************************************************************
'
' Generic file reader. Return the content of the text file
'
' *************************************************************
Private Function readFile(ByVal sFileName As String) As String

    Dim objFso As Object
    Dim objFile As Object
    Dim sContent As String

    Set objFso = CreateObject("Scripting.FileSystemObject")

    If Not (objFso.FileExists(sFileName)) Then
        ' The file didn't exist
        readFile = ""
        Exit Function
    End If

    Set objFile = objFso.OpenTextFile(sFileName, 1)

    sContent = objFile.readAll

    objFile.Close

    Set objFile = Nothing
    Set objFso = Nothing

    readFile = sContent

End Function

' *************************************************************
'
' Return a filename with the response of the web service method
'
' *************************************************************
Private Function consumeWebService(ByVal sURL As String, ByVal sData As String) As String

    Dim xmlhttp As Object
    Dim sResponseFileName As String

    Set xmlhttp = New MSXML2.ServerXMLHTTP60  ' Requires Microsoft XML, v6.0

    xmlhttp.Open "POST", sURL, True
    xmlhttp.send sData
    xmlhttp.waitForResponse

    sResponseFileName = createXmlTempFile(xmlhttp.responseText)

    Set xmlhttp = Nothing

    consumeWebService = sResponseFileName

End Function

' *************************************************************
'
' Create a temporary file in the TEMP folder and write in that
' file the XML response received by the web service.
'
' Return the temporary filename as result of this function
'
' *************************************************************
Private Function createXmlTempFile(ByVal sContent As String) As String

    Dim objFso As Object
    Dim objFile As Object
    Dim objFolder As Object
    Dim sFileName As String

    Set objFso = CreateObject("Scripting.FileSystemObject")

    ' 2 = temporary folder
    Set objFolder = objFso.GetSpecialFolder(2)
    sFileName = objFolder & "\"
    Set objFolder = Nothing

    sFileName = sFileName & objFso.GetTempName()
    sFileName = Replace(sFileName, ".tmp", ".xml")

    Set objFile = objFso.CreateTextFile(sFileName)

    objFile.Write sContent

    objFile.Close

    Set objFile = Nothing
    Set objFso = Nothing

    createXmlTempFile = sFileName

End Function
```

### À propos des placeholders {#about-placeholders}

Dans notre fichier `C:\temp\checkVat.xml`, nous avons donc prévu deux placeholders.

Vous pouvez voir dans la sous-routine VBA `openCheckVatXml` comment nous les remplaçons par des valeurs d'exemple. Adaptez-les simplement aux vôtres.

## Une version en ligne de commande Linux {#a-linux-command-line-version}

Pour ceux que ça intéresse, voici une autre façon d'obtenir le même résultat, mais depuis une console Linux (ou DOS si vous avez curl installé) :

```bash
curl --silent http://ec.europa.eu/taxation_customs/vies/services/checkVatService   \
  -w \\n                                          \
  -H 'SOAPAction: "checkVat"'                        \
  -H "Content-Type: text/xml;charset=UTF-8"          \
  -d '<?xml version="1.0" encoding="UTF-8"?>
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
    <soapenv:Body>
        <urn:checkVat xmlns:urn="urn:ec.europa.eu:taxud:vies:services:checkVat:types">
            <urn:countryCode>BE</urn:countryCode>
            <urn:vatNumber>0403170701</urn:vatNumber>
        </urn:checkVat>
    </soapenv:Body>
</soapenv:Envelope>'
```

> **Ajoutez `xmlstarlet` pour une sortie plus lisible:**
>
> Voyez mon article [The xmlstarlet utility for Linux](/blog/linux-xmlstarlet).
>
> Ajoutez `| xmlstarlet format --indent-spaces 4` à la fin de la commande précédente pour envoyer la sortie vers `xmlstarlet` (voir [The xmlstarlet utility for Linux](/blog/linux-xmlstarlet))

La réponse sera :

```xml
<?xml version="1.0"?>
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
    <env:Header/>
    <env:Body>
        <ns2:checkVatResponse xmlns:ns2="urn:ec.europa.eu:taxud:vies:services:checkVat:types">
            <ns2:countryCode>BE</ns2:countryCode>
            <ns2:vatNumber>0403170701</ns2:vatNumber>
            <ns2:requestDate>2024-01-07+01:00</ns2:requestDate>
            <ns2:valid>true</ns2:valid>
            <ns2:name>SA ELECTRABEL</ns2:name>
            <ns2:address>Boulevard Simon Bolivar 36\n1000 Bruxelles</ns2:address>
        </ns2:checkVatResponse>
    </env:Body>
</env:Envelope>
```

À vous maintenant de modifier le code VBA et de l'adapter à vos besoins.

Si vous concevez le côté API plutôt que de simplement la consommer, lisez [API REST - How to write good APIs](/blog/php-api-tips) pour le contexte général de conception d'API.


---

<!--
  canonical-url: https://www.avonture.be/fr/blog/msaccess-optimize
  published:     2024-03-09
  This is a static plain-Markdown mirror generated at build time.
  Visit the canonical URL above for the fully rendered page, with images and interactive components.
-->

# Comment optimiser une base de données MS Access existante

> Accélérez votre base de données Microsoft Access lente grâce à ce guide d'optimisation pas à pas. Apprenez à améliorer la structure des tables, à utiliser les index, à optimiser les requêtes et à compacter votre base pour de meilleures performances.

---
![Comment optimiser une base de données MS Access existante](/img/v2/msaccess.webp)

**TL;DR**

Voici une checklist complète pour accélérer une base MS Access existante sans la ré-architecturer : ajouter des clés primaires et des index, utiliser les bons types et tailles de champs, préférer le SQL natif (`Is Null`, `Iif()`, `BETWEEN`) aux fonctions VBA (`IsNull()`, `NZ()`, `Year()`) qui contournent les index, filtrer avec `WHERE` avant `HAVING`, convertir les macros en modules VBA, compiler le code et compacter la base.

Il y a plusieurs années, j'ai dû intervenir sur une base de données MS Access créée par une personne de bonne volonté mais avec peu d'affinités pour l'informatique et l'optimisation.

Le résultat : une base lourde et d'une lenteur exaspérante.

Dans cet article, ressorti de mes archives personnelles, je vais présenter les différentes étapes par lesquelles je suis passé.

> **Avertissement:**
>
> Ce guide concerne délibérément les **bases de données existantes** ; pour cette raison, je ne parlerai pas de la manière de concevoir correctement des tables, de garder un nombre de champs raisonnable ou de dessiner un schéma relationnel, ... L'objectif est donc d'améliorer les performances sans programmation profonde (pas de ré-architecture) et sans [migrer vers, par exemple, SQL Server](/blog/docker-mssql-server).
>
> *Pour savoir **quels** champs sont surdimensionnés avant de les réduire, lancez le script d'audit de [VBS - Retrieve the list of fields in a MS Access Database](/blog/vbs-msaccess-get-fields) : il indique, pour chaque champ, sa taille déclarée à côté de la plus longue valeur réellement stockée.*

## MS Access - Analyser les performances {#ms-access---analyze-performance}

MS Access 2016 fournit un outil pour analyser la base de données courante.

![MS Access - Analyser les performances](./images/access_analyze_performance.webp)

Vous pouvez lancer l'outil sur une sélection uniquement, par exemple sur les requêtes seulement.

## À faire vous-même {#do-it-yourself}

### Tables {#tables}

#### Ajouter une clé primaire dans chaque table {#add-a-primary-key-in-each-table}

Selon votre modèle de données, essayez d'ajouter une clé primaire dans chaque table.

Par exemple, si vous avez une table Client, vous aurez probablement un champ qui identifie sans aucun doute un client donné ; un champ comme `CustomerID` (quel que soit son nom).

Examinez toutes vos tables et, si vous disposez d'un tel champ unique, définissez-le comme clé primaire.

Si possible, une clé primaire devrait être

* un seul champ (vous pouvez en effet définir plusieurs champs comme clé),
* un nombre, pas un champ texte,
* aussi petite que possible (si vous avez vraiment besoin d'un champ texte, préférez par exemple un champ de 5 caractères et non de 255)

Faites un clic droit sur le nom de la table et choisissez `Design`.

![Ouvrir la table en mode création](./images/design.webp)

Sélectionnez le champ puis cliquez sur le bouton `Primary key`.

![Ajouter une clé primaire](./images/primarykey_add.webp)

Attention : assurez-vous d'identifier correctement le champ unique ; n'ajoutez pas une clé primaire sur, par exemple, un nom de client (puisque plusieurs clients peuvent porter le même nom). Une clé primaire augmentera la vitesse et la cohérence des données de votre table, mais empêchera aussi d'avoir un second enregistrement avec la même clé (donc, si vous choisissez le mauvais champ, vous pouvez avoir des effets de bord).

#### Utiliser des index {#use-indexes}

Regardez vos requêtes : filtrez-vous souvent sur un champ précis ? Vous pourriez obtenir un très net gain de performance en ajoutant simplement un index sur ce champ.

Pour ce faire, ouvrez votre table en mode création en faisant simplement un clic droit sur le nom de la table

![Ouvrir la table en mode création](./images/design.webp)

Cliquez ensuite sur le bouton `Indexes` pour afficher une petite fenêtre et, là, ajoutez des index sur les champs importants.

![Ajouter des index](./images/index_add.webp)

Note : n'en abusez pas, ne *sur-indexez* pas. N'ajoutez des index que sur les champs souvent utilisés dans les critères de requête, car maintenir un index consomme du CPU et a donc un coût sur les instructions d'insertion, de mise à jour et de suppression.

#### Créer des relations entre les tables si possible {#create-relationships-between-tables-if-possible}

Lorsque vous utilisez, dans une requête, deux tables ou plus ayant un lien entre elles, les techniques d'optimisation de MS Access suggèrent de créer ce lien également dans la fenêtre des relations, c'est-à-dire à un niveau global.

Pour ce faire, une fois votre base ouverte, cliquez sur le menu `Database Tools` et choisissez `Relationships`.

Dessinez votre relation, sélectionnez soigneusement le type de jointure (qui peut aussi être ajusté dans une requête) et enregistrez les relations.

![Créer des relations entre les tables](./images/relationships.webp)

Exemple : lien entre deux tables sur l'`ID` de la première table et le champ associé, `tblOneID` dans la seconde. La flèche est dessinée de `table1` vers `table2` (c'est le `join type`) et cela signifie : « prends tous les enregistrements de `table1` et, si la valeur est aussi connue dans `table2`, alors retourne les valeurs ».

Astuce : essayez toujours d'utiliser un index pour la relation et pas « n'importe quel champ ».

![Exemple de relation entre deux tables](./images/relationships_sample.webp)

#### Utiliser le bon type de données et la bonne taille {#use-the-right-data-type-and-the-right-size}

Dans vos tables, essayez de bien choisir le type de données :

* si vous devez stocker une information Vrai/Faux (ou 1/0), choisissez un `Yes/No`
* si vous devez stocker un petit nombre (par exemple `Number of children`), ne choisissez pas Number - Long Integer alors que Number - Byte suffit,
* ...

Et la bonne taille : surtout pour les champs texte, n'utilisez pas une longueur de 255 (ce n'est presque jamais nécessaire) mais essayez de penser à la valeur la plus longue (avez-vous vraiment un client avec un nom de famille de 255 caractères ? 50 suffiront probablement).

### Requêtes {#queries}

#### Utiliser Between {#use-between}

Quand vous devez écrire un critère `between`, par exemple ID entre 5 et 9, vous pouvez le faire comme ceci :

![Préférez BETWEEN](./images/query_between.webp)

* Deux fois la même colonne, une avec `>= 5` et la seconde avec `< 10`
* Ou dans la même colonne avec un `Between 5 and 9`

La meilleure approche est celle en jaune : un seul champ et donc un seul critère à évaluer.

#### Compter le nombre d'enregistrements {#count-the-number-of-records}

Si vous utilisez la fonction Count pour calculer le nombre d'enregistrements retournés par une requête, utilisez la syntaxe `Count(*)` plutôt que `Count([some_field])`.

`Count(*)` est plus rapide car il n'a pas à vérifier les valeurs Null dans le champ indiqué et n'ignorera pas les enregistrements nuls.

*En utilisant `Count([some_field])`, le nombre retourné **peut être plus faible** que le nombre réel d'enregistrements si la colonne `some_field` vaut parfois Null.*

#### Uniquement les champs nécessaires {#only-needed-fields}

Si vous utilisez une requête dans une autre requête, comme illustré ci-dessous, et que vous n'avez besoin que de trois champs dans la seconde requête, la première peut peut-être être modifiée pour ne retourner que ces trois champs.

![Requête utilisant une autre requête](./images/query_on_query.webp)

Si, dans cet exemple, la requête appelée `qryFirst` n'est utilisée que par cette seconde requête, alors vous pouvez modifier la première pour ne retourner que trois colonnes.

Moins il y a de données retournées, plus la requête sera traitée rapidement.

#### Utiliser Is Null et pas IsNull() {#use-is-null-and-not-isnull}

Dans une requête, utilisez `Is Null` qui est natif dans le standard SQL alors que `IsNull()` est en réalité une fonctionnalité VBA.

Utiliser `IsNull()` est donc plus lent que `Is Null`.

Évitez donc,

```SQL
SELECT ... FROM ... WHERE IsNull(fld)
```

Et utilisez,

```SQL
SELECT ... FROM ... WHERE (fld Is Null)
```

#### Utiliser Iif() et pas NZ() {#use-iif-and-not-nz}

NZ() est une fonctionnalité VBA : si un champ vaut Null, NZ() vous permet de retourner autre chose.

Iif() est du SQL natif.

Illustration simplifiée : si la date d'embauche est nulle, on suppose qu'il s'agissait du 1er janvier 2000.

```SQL
SELECT NZ([dteHiring], #2000-01-01#) As dteEntry
```

La même chose peut aussi s'écrire comme ceci :

```SQL
SELECT Iif([dteHiring] Is Null, #2000-01-01#, [dteHiring]) As dteEntry
```

Pourquoi est-ce mauvais ? **NZ() retournera un objet variant, moins performant, car le moteur .JET de MS Access traite les Variants comme du texte**. Dans le premier exemple `NZ([dteHiring], #2000-01-01#) As dteEntry`, le type de données de dteEntry est donc un champ texte, pas une date.

Donc, dans l'exemple ci-dessous, nous ne comparons pas une date avec une autre date mais une date `dteEntry` avec un texte (le résultat de la formule `NZ()`). Le moteur .JET va donc convertir `dteEntry` en texte aussi. La conversion est donc faite deux fois et c'est inefficace.

![Utiliser NZ() comme critère](./images/nz_date.webp)

Avec `Iif([dteHiring] Is Null, #2000-01-01#, [dteHiring]) As dteEntry`, le type reste un champ date. Nous pouvons donc rapidement résoudre la double conversion introduite par `NZ()` avec cette construction :

![Utiliser Iif() comme critère](./images/iif_date.webp)

Ici, .JET ne se plaindra plus et comparera immédiatement une date avec une autre date ; c'est plus rapide.

#### Éviter les fonctions VBA {#avoid-vba-functions}

Nous l'avons déjà vu. Utilisez `Is Null` et pas `IsNull()`, utilisez `Iif` et pas `NZ()`, et cela s'applique à beaucoup d'autres formules.

##### Year() {#year}

Year() est une fonction VBA. La requête ci-dessous exige que chaque date soit traitée par Year() pour déterminer l'année avant d'évaluer le critère.

S'il existe un index sur `dteHiring`, cet index est ignoré à cause de l'appel VBA.

```SQL
SELECT ... FROM ... WHERE (Year([dteHiring]) = 2018)
```

Préférez le verbe SQL natif `BETWEEN` :

```SQL
SELECT ... FROM ... WHERE ([dteHiring] between '1/1/2018 00:00:00' and '12/31/2018 23:59:59')
```

Ici l'index est bien utilisé, .JET n'a pas non plus besoin de faire un appel VBA enregistrement par enregistrement mais peut travailler sur un ensemble d'enregistrements d'un coup.

##### DCount(), DSum() {#dcount-dsum}

Préférez réécrire la requête et utiliser, par exemple, des sous-requêtes avec un GROUP BY et la formule souhaitée (Count(), Sum(), ...)

#### Trier sur des colonnes, pas sur des formules {#sorting-on-columns-not-formulas}

Si possible, il est préférable d'utiliser le tri sur des colonnes (et donc probablement d'utiliser des index).

Dans l'exemple suivant, l'ORDER BY porte sur une formule (une concaténation de chaînes) ; aucun index ne peut être utilisé ici, donc le temps nécessaire au tri des enregistrements est plus long.

```SQL
SELECT ClientID, Name + " " + FirstName As FullName
FROM tblClient
ORDER BY Name + " " + FirstName
```

Dans l'exemple ci-dessous, le résultat sera exactement le même, sauf que si une ou les deux colonnes sont indexées, le résultat sera plus rapide.

```SQL
SELECT ClientID, Name + ", " + FirstName As FullName
FROM tblClient
ORDER BY Name, FirstName
```

#### Utiliser le même type de données (ou un type compatible) dans les champs de jointure {#use-the-same-or-compatible-data-type-in-join-fields}

Quand vous faites un lien entre deux tables (avec une jointure), essayez de respecter le type de données : évitez de lier par exemple un nombre et un champ texte.

Prenons l'exemple suivant :

![Relation](./images/sametype_relation.webp)

*Le champ `ID` dans `tblCustomer` est un nombre*

![Client](./images/sametype_customer.webp)

*Le champ `CustomerNumber` dans `tblOrder` est un texte (et un grand)*

![Commandes](./images/sametype_orders.webp)

MS Access sera capable de faire la jointure et cela fonctionnera, mais il convertira implicitement les champs pour qu'ils aient le même type de données, et cela coûtera du CPU.

Dans cet exemple, si possible, changez le type de données de `CustomerNumber` dans `tblOrder` en `Long integer` pour que les champs soient compatibles.

#### Filtrer d'abord avec WHERE avant HAVING {#first-filter-by-using-where-before-having}

Les requêtes de totaux (celles avec une clause `GROUP BY`) peuvent avoir à la fois une clause `WHERE` et une clause `HAVING`.

* `WHERE` est exécuté en premier, **avant l'agrégation**
* `HAVING` est exécuté ensuite, **quand les totaux ont été calculés**

Ci-dessous, il n'y a pas de clause `WHERE` : le calcul « combien de factures par client » est fait pour tous les clients (plusieurs milliers peut-être) et, une fois tout ce calcul terminé, vous demandez juste le chiffre du client 99. Plutôt inefficace.

```SQL
SELECT ClientID, Count(InvoiceID) AS HowMany
FROM tblInvoice
GROUP BY ClientID
HAVING ClientID = 99;
```

Profitez de la priorité de `WHERE` et obtenez la même information, bien plus vite, comme ceci :

```SQL
SELECT ClientID, Count(InvoiceID) AS HowMany
FROM tblInvoice
WHERE ClientID = 99
GROUP BY ClientID;
```

Ici, .JET ne prend que les enregistrements de ce client avant de commencer à compter.

#### Si vous groupez sur la clé primaire {#if-youre-group-on-the-primary-key}

Dès que vous utilisez un GROUP BY dans votre SQL, tout champ « non » calculé doit être mentionné dans la clause GROUP BY.

Comme nous n'utilisons pas une formule du type Count(), Max(), ... sur LastName, ce champ doit être mentionné dans la clause GROUP BY, donc :

```SQL
SELECT EmployeeID, LastName, Count(Illness)
FROM Employees
GROUP BY EmployeeID, LastName
```

Mais ici, grouper sur LastName est inutile car EmployeeID est déjà unique : quand on utilise la clé primaire dans le GROUP BY, tout autre champ est superflu et, à cause de leur présence, .JET va grouper pour rien. Des actions inutiles...

Comme la clé primaire est dans la clause GROUP BY, nous pouvons utiliser ce SQL :

```SQL
SELECT EmployeeID, First(LastName) AS LastName, Count(Illness) As IllDays
FROM Employees
GROUP BY EmployeeID
```

En utilisant First(), nous permettons à .JET de ne retenir que le premier LastName pour cet Employee ID (et, bien sûr, l'employé n'a qu'un seul LastName).

C'est donc plus rapide.

### Macros {#macros}

#### Convertir les macros en modules {#convert-macros-to-modules}

Convertir une macro en code Visual Basic for Applications (VBA) peut permettre à certaines actions de s'exécuter plus vite.

Pour convertir une macro en VBA, sélectionnez la macro (ne l'ouvrez pas, sélectionnez-la simplement) et, dans l'onglet `Database Tools`, cliquez sur `Convert Macros to Visual Basic`.

Ensuite, une fois cela fait, vous devrez probablement mettre à jour votre interface : si vous avez des formulaires, vous devrez par exemple mettre à jour les boutons pour qu'ils déclenchent le module VBA au lieu des macros.

Si tout se passe bien, supprimez simplement les macros converties.

### Modules {#modules}

#### Enregistrer les modules à l'état compilé {#save-modules-in-a-compiled-state}

Si la base contient des modules, assurez-vous, dans la version de production, de compiler le code source. Il suffit d'ouvrir un module (peu importe lequel) et de cliquer sur le menu `Debug` puis `Compile`.

![État compilé](./images/compiled_state.webp)

#### Utiliser l'instruction Option Explicit {#use-option-explicit-statement}

Si vous avez des modules ou des événements de formulaire codés en VBA, ouvrez chaque module / formulaire (appuyez ensuite sur `ALT-F11` pour ouvrir l'éditeur) et, à la toute première ligne de votre code, tapez `Option Explicit` comme par exemple :

```vbnet
Option Compare Database
Option Explicit

Sub DoSomething()
    ' your own code
End Sub
```

Option Explicit force le moteur VB à vérifier que les variables existent avant de commencer à exécuter le code, et non chaque fois qu'une variable est accédée. Cela donne un petit gain de vitesse.

> **Caution:**
>
> Option Explicit est avant tout une excellente pratique de codage : les variables doivent être déclarées avant d'être utilisées.

#### Décharger les références {#unload-references}

Regardez, dans votre code, si vous référencez trop de dépendances externes.

Depuis l'éditeur VB, cliquez sur le menu `Tools` puis choisissez `References` et faites attention aux premiers éléments de la liste, ceux qui sont cochés. En avez-vous vraiment besoin ?

Un moyen simple de répondre à cette question est de les décocher et de cliquer sur le bouton `OK`.

Cliquez sur le menu `Debug` et choisissez `Compile`. Si vous obtenez des erreurs de compilation (et qu'il n'y en avait pas avant), retournez dans la fenêtre `References` et recochez la bibliothèque.

![Décharger les références non utilisées](./images/unload_references.webp)

La plupart du temps, seules deux références sont nécessaires :

1. `Visual Basic For Applications` (toujours en haut)
2. `Microsoft Access 16.0 Object Library` (la deuxième) (Note : « 16.0 » est variable et dépend de la version de MS Office installée)

### Base de données {#database}

#### Compacter la base de données {#compact-the-database}

Si vous avez des tables temporaires, supprimez-les au préalable.

Compacter la base libérera de l'espace, supprimera les objets et enregistrements inutiles et mettra à jour les statistiques internes ; cela aura un impact positif sur les performances.

#### Enregistrer la base en fichier .mde {#save-the-database-as-a-mde-file}

**!!! Attention !!!**

Un fichier .mde est plus petit et plus rapide qu'un fichier MS Access normal (fichier .accdb) mais vous ne pouvez plus modifier la structure d'un tel fichier.

Avec un .mde, vous ne pourrez plus changer la structure d'une table, ajouter un champ, modifier vos formulaires, ... mais seulement les utiliser.

![Enregistrer sous - MDE](./images/save_as_mde.webp)

**Si vous souhaitez utiliser un .mde, faites toujours une sauvegarde de votre fichier .accdb (ou .mdb) et gardez-la dans un dossier sécurisé. Encore une fois : si vous n'avez plus le fichier .accdb mais seulement le .mde, vous ne pourrez plus changer la structure de l'application, vous ne pourrez plus modifier une macro, un formulaire, ...**

> **Scanner toutes les tables et exporter une liste exhaustive des champs dans Excel:**
>
> Voyez aussi mon article [VBS - Retrieve the list of fields in a MS Access Database](/blog/vbs-msaccess-get-fields).


---

<!--
  canonical-url: https://www.avonture.be/fr/blog/vbs-msaccess-get-fields
  published:     2024-03-09
  This is a static plain-Markdown mirror generated at build time.
  Visit the canonical URL above for the fully rendered page, with images and interactive components.
-->

# VBS - Récupérer la liste des champs d'une base de données MS Access

> Utilisez un VBScript pour récupérer facilement la liste détaillée des champs de votre base de données MS Access. Analysez la taille, le type et la longueur réelle des valeurs pour optimiser la structure de votre base.

---
![VBS - Récupérer la liste des champs d'une base de données MS Access](/img/v2/msaccess.webp)

**TL;DR**

Cet article partage un script VBS qui parcourt toutes les tables d'une base MS Access et exporte vers Excel un rapport détaillé des champs — nom, type, taille définie et valeur la plus courte/la plus longue réellement présente dans les données. De quoi repérer d'un coup d'œil les champs surdimensionnés (par exemple un champ de 255 caractères qui n'en contient jamais plus de 10) qu'il vaut la peine de réduire.

Il y a des années, j'ai écrit un script .vbs qui analyse une base de données MS Access, boucle sur chaque table et, pour chacune d'elles, récupère la liste des champs.

Pour chaque champ, beaucoup d'informations sont récupérées (liste non exhaustive) : son nom, sa taille, son type, ... ainsi que la taille de la plus petite et de la plus grande valeur (pour les champs texte et mémo). Par exemple, si un champ texte est trouvé, le script récupère sa taille (p.ex. 255 caractères max) et examine tous les enregistrements de la table pour trouver, pour ce champ, la plus petite taille (p.ex. 10) et la plus grande (p.ex. 50). Donc, si la taille maximale constatée est de 50 et que la taille définie est de 255, le développeur MS Access peut sans doute ramener sans risque cette taille de 255 à 50.

## Le rapport que vous obtenez {#the-report-youll-get}

Double-cliquez sur un fichier `.cmd`, patientez quelques secondes, et Excel s'ouvre tout seul sur ceci :

![MS Access Get fields list](./images/get_fields_list.webp)

Une ligne par champ, pour chaque table de la base, avec côte à côte les deux colonnes qui comptent pour l'optimisation : `FieldSize` (ce que la table autorise) et `LongestSize` (ce que les données utilisent réellement).

## Comprendre le rapport {#understand-the-report}

* Filename : le nom du fichier MS Access (absolu)
* TableName : le nom de la table
* FieldName : le nom du champ trouvé dans cette table
* FieldType : le type de données (integer, string, date, ...)
* FieldSize : la taille maximale définie dans la table (p.ex. 255 signifie que ce champ peut contenir jusqu'à 255 caractères)
* ShortestSize : lorsque la table contient des enregistrements, l'info ShortestSize répond à « quelle est la plus petite information stockée dans ce champ ? » (exemple : si le champ est un prénom, de taille 255, mais que le prénom le plus court est `Paul`, alors `ShortestSize` vaudra 4)
* LongestSize : lorsque la table contient des enregistrements, l'info `LongestSize` répond à « quelle est la plus grande information stockée dans ce champ ? » (exemple : si le champ est un prénom, de taille 255, mais que le prénom le plus long est `Christophe`, alors `LongestSize` vaudra 10)
* Position : la position de ce champ dans la structure de la table (est-ce le premier champ défini, le deuxième, ...)
* Occurrences : combien de fois ce `FieldName` précis apparaît dans toute la base. Si vous avez beaucoup de tables, le champ appelé `CustomerID` est peut-être utilisé dans la table `Customers` et aussi dans la table `Orders` : `Occurrences` vaudra donc 2 dans ce cas.

## Comment le reproduire {#how-to-reproduce-it}

1. Copiez/collez le code source des deux scripts (voir ci-dessous) et enregistrez-les dans des fichiers texte (avec Notepad). Le premier fichier à créer sera `access_get_fields_list.vbs`, le second `access_get_fields_list.cmd`,
2. Avant d'enregistrer `access_get_fields_list.cmd`, éditez bien le fichier et indiquez le nom complet de votre base de données,
3. Vous êtes prêt : depuis l'Explorateur de fichiers, double-cliquez simplement sur `access_get_fields_list.cmd`. Le script d'analyse s'exécute et Excel s'ouvre à la fin.

*Si tout se passe bien, vous verrez une fenêtre DOS et, après quelques secondes (selon la taille et la complexité de la base), vous aurez le rapport dans Excel, ouvert automatiquement.*

### access\_get\_fields\_list.vbs {#access\_get\_fields\_listvbs}

Récupérez le code source sur ma page GitHub : <https://github.com/cavo789/vbs_access_get_fields_list/blob/master/access_get_fields_list.vbs>.

Copiez le code dans Notepad par exemple, puis enregistrez-le sur votre disque, p.ex. sous le nom `access_get_fields_list.vbs`.

### access\_get\_fields\_list.cmd {#access\_get\_fields\_listcmd}

Procédez de la même manière pour le script <https://github.com/cavo789/vbs_access_get_fields_list/blob/master/access_get_fields_list.cmd>. Copiez/collez la ligne dans Notepad et pensez à changer le nom de la base (plus `C:\temp\my_db.accdb` mais la vôtre).

Enregistrez le fichier sur votre disque dur sous le nom `access_get_fields_list.cmd`. Vous pouvez ensuite quitter Notepad.

## Que faire de ces chiffres {#what-to-do-with-the-numbers}

Dans un contexte d'optimisation (voir aussi [How to optimize an existing MS Access database](/blog/msaccess-optimize)) :

* Veillez à ne pas utiliser une taille de champ trop grande. Par défaut, MS Access propose une taille de 255 pour les champs texte, mais pour un champ nom ou prénom, 40 caractères suffisent.
* Regardez la propriété `LongestSize` : si vous voyez p.ex. une taille de 4, c'est que vous stockez probablement un code (un code postal fait au maximum 4 chiffres en Belgique). Si `FieldSize` vaut 50, vous savez que vous pouvez réduire cette taille à 4.

## Conclusion {#conclusion}

Deux scripts, un double-clic, et la structure d'une base héritée s'affiche sous forme de feuille Excel triable. L'écart entre `FieldSize` et `LongestSize`, c'est là que se cache l'espace gaspillé, et le lire prend une minute plutôt que d'ouvrir trente tables en mode création.

Même esprit « auditer une base existante », angle différent : [Export MS Access objects](/blog/vba-access-export) sort vos formulaires, requêtes et modules sous forme de fichiers texte, prêts à être comparés avec un diff.


---

<!--
  canonical-url: https://www.avonture.be/fr/blog/vbs-auto-update
  published:     2024-03-19
  This is a static plain-Markdown mirror generated at build time.
  Visit the canonical URL above for the fully rendered page, with images and interactive components.
-->

# VBS - Script d'auto-mise à jour

> Automatisez les mises à jour de vos scripts console VBS (Visual Basic Script) ! Découvrez comment créer un fichier VBS qui se met à jour lui-même, se connecte à GitHub, vérifie les nouvelles versions et s'écrase.

---
![VBS - Script d'auto-mise à jour](/img/v2/vbs.webp)

**TL;DR**

Cet article montre comment donner à un fichier VBScript (VBS) la capacité de se mettre à jour lui-même : à chaque exécution, le script télécharge son propre code source depuis une URL GitHub publique, la compare à la copie locale et s'écrase si une version plus récente est trouvée — ce qui permet aux utilitaires `.vbs` distribués de rester à jour sans redistribution manuelle.

Avant de passer à [WSL2](/blog/tags/wsl) et à la console Linux, j'écrivais des scripts VBS de temps en temps. Ça ressemble à du VBA, mais pour la console DOS.

Un script VBS pour DOS est un fichier texte écrit dans le langage de programmation Visual Basic Scripting Edition (VBScript), exécutable directement depuis la ligne de commande DOS. Il permet d'automatiser des tâches et d'effectuer des opérations répétitives sur votre ordinateur.

C'est exactement comme les scripts [Linux Bash](/blog/tags/bash), mais pour DOS.

*Trois de mes utilitaires VBS qui bénéficieraient précisément de ce mécanisme d'auto-mise à jour : [VBS - Retrieve the list of fields in a MS Access Database](/blog/vbs-msaccess-get-fields), [Export MS Access objects](/blog/vba-access-export) et [VBS - Get list of files and generate a CSV](/blog/vbs-files-csv).*

Pensez-vous qu'il serait possible de proposer une fonction d'auto-mise à jour dans de tels scripts ? La réponse est oui.

Imaginez un script appelé `get_folder_size.vbs` que vous avez publié publiquement sur GitHub (source <https://github.com/cavo789/vbs_utilities/blob/master/src/folders/get_folder_size/get_folder_size.vbs>).

Quelqu'un le télécharge sur son ordinateur et prend plaisir à l'utiliser.

En y ajoutant une nouvelle fonction d'*auto-mise à jour*, à chaque démarrage du script, une connexion à GitHub est d'abord établie, le script est téléchargé depuis là, et une vérification est faite pour voir si la version téléchargée est différente ; si c'est le cas, le script s'écrase lui-même.

Voici le contenu d'une telle fonction :

**get\_folder\_size.vbs**

```vbs
' -----------------------------------------------------------------
'
' Connect to GitHub, get the raw version of a file and download it
'
' The script will check for newer version on GitHub and if
' there is one, the script will overwrite himself with
' that newer version.
'
' Based on a script of
' @author Michi Lehenauer §https://github.com/michiil)
' then modified by Christophe Avonture
'
' @src https://github.com/michiil/vbs_scrips/blob/master/WZV-Excel.vbs
' -----------------------------------------------------------------

' The content to download
url = "https://raw.githubusercontent.com/cavo789/vbs_utilities/master/src/folders/get_folder_size/get_folder_size.vbs"

Set req = CreateObject("Msxml2.ServerXMLHttp.6.0")

req.setTimeouts 500, 500, 500, 500

' If you're behind a firewall, uncomment the following line
' and mention the proxy address and port
'req.setProxy 2, "your.proxy.net:8080", ""

req.open "GET", url, False
req.send

If Err.Number = 0 Then
  If req.Status = 200 Then
    ' Get the content, just downloaded
    downloadedContent = req.responseText

    ' Get the original content, this script

    scriptName = wScript.ScriptFullName
    Set objFSO = CreateObject("Scripting.FileSystemObject")
    Set textFile = objFSO.OpenTextFile(scriptName, 1)
    originalContent = textFile.ReadAll
    textFile.Close

    ' Compare if the two contents are different
    If (originalContent <> downloadedContent) Then
      ' If yes, for instance, rewrite this script by
      ' the new content ==> auto-update
      Set textFile = objFSO.OpenTextFile(scriptName, 2)

      textFile.Write (downloadedContent)
      textFile.Close

      'wScript.echo scriptName & " has been updated"
    End If

    Set textFile = Nothing
    Set objFSO = Nothing

  End If
Else
    ' Ok, in case of error, don't panic, just do nothing
    Err.Clear
End If
```


---

<!--
  canonical-url: https://www.avonture.be/fr/blog/outlook-vba-pdf
  published:     2024-07-10
  This is a static plain-Markdown mirror generated at build time.
  Visit the canonical URL above for the fully rendered page, with images and interactive components.
-->

# Microsoft Outlook - VBA - Enregistrer des emails en PDF

> Découvrez comment mettre en place une macro VBA dans Microsoft Outlook pour enregistrer facilement les emails sélectionnés sous forme de fichiers PDF sur votre disque dur, avec les instructions d'installation et d'utilisation pas à pas.

---
![Microsoft Outlook - VBA - Enregistrer des emails en PDF](/img/v2/outlook_vba.webp)

**TL;DR**

Cet article partage une macro VBA pour le client Outlook de bureau qui enregistre un ou plusieurs emails sélectionnés en fichiers PDF, ajoutée au Ribbon comme bouton personnalisé via l'éditeur VBA. À l'exécution, elle demande le dossier de destination, si les emails doivent être supprimés d'Outlook après l'export, et si chaque PDF doit être nommé manuellement ou d'après le sujet de l'email.

Vous aurez peut-être besoin, vous aussi, de sélectionner plusieurs emails dans Microsoft Outlook et de les enregistrer en [fichiers PDF](/blog/markitdown) sur votre disque dur.

Dans mon cas, c'était à l'époque où j'étais indépendant à titre complémentaire. Je devais garder une trace des commandes reçues et des factures envoyées. Enregistrer mes commandes en PDF me permettait de les conserver comme archives, même en cas de panne de mon serveur mail.

Cet article va vous expliquer comment créer une telle macro pour Outlook.

## Résultat {#result}

Sélectionnez un ou plusieurs emails, cliquez sur le bouton, et la macro vous guide à travers trois questions :

![Cinq emails sélectionnés](./images/five_emails_selected.webp)

1. Une confirmation pour continuer avec les emails sélectionnés.
2. Un sélecteur de dossier — où les PDF doivent être enregistrés.
3. Faut-il supprimer les emails d'Outlook ensuite, et faut-il nommer chaque PDF manuellement ou réutiliser le sujet de l'email.

À la fin, chaque email sélectionné est enregistré sur votre disque dur en PDF.

## Prérequis {#prerequisites}

Vous devez avoir Microsoft Office sur votre disque dur, et Outlook ainsi que Word doivent être installés.

La macro ne fonctionnera pas avec Office en ligne.

## Étapes d'installation {#installation-steps}

**Étapes d'installation**

1. Démarrez simplement votre client Microsoft Outlook (le logiciel installé sur votre disque dur ; pas la version dans votre navigateur),

2. Appuyez sur <kbd>ALT</kbd>+<kbd>F11</kbd> pour ouvrir la fenêtre `Visual Basic Editor` (aussi appelée `VBE`),

3. Cliquez sur le menu `Insert` puis `Module`,

4. Cliquez sur le lien <a href="https://github.com/cavo789/vba_outlook_save_pdf/blob/master/module.bas"><https://github.com/cavo789/vba_outlook_save_pdf/blob/master/module.bas></a> pour ouvrir mon repository sur GitHub, puis cliquez sur le bouton `Copy raw file` pour copier le code source dans le presse-papiers

5. Revenez dans Outlook et appuyez sur <kbd>CTRL</kbd>+<kbd>V</kbd> dans l’éditeur pour y coller le code,

6. Fermez le `Visual Basic Editor` et revenez à Outlook,

7. Cliquez n’importe où sur le Ribbon et choisissez `Customize the Ribbon...`

8. Dans la nouvelle boîte de dialogue, cliquez sur le bouton `New Group`

9. Dans *Choose commands from*, sélectionnez `Macros` ; vous devriez voir la macro `SaveAsPDFFile` comme illustré ci-dessous.

10. Glissez-déposez la macro dans votre nouveau groupe.

11. Cliquez sur le bouton `OK` pour fermer la boîte de dialogue.

Vous devriez voir [votre nouveau groupe](/blog/vba-excel-ribbon) ; dans mon cas, je l'ai créé dans `Home`, tout à gauche en première position, ce qui donne ceci :

![Le nouveau groupe](./images/ribbon_macro.webp)

## Les boîtes de dialogue de dossier et de nommage {#the-folder-and-naming-dialogs}

La confirmation, le sélecteur de dossier et les questions de nommage sont décrits en début d'article. Le sélecteur de dossier ressemble à ceci :

![Où enregistrer les emails ?](./images/where_to_save.webp)


---

<!--
  canonical-url: https://www.avonture.be/fr/blog/vbs-files-csv
  published:     2024-11-28
  This is a static plain-Markdown mirror generated at build time.
  Visit the canonical URL above for the fully rendered page, with images and interactive components.
-->

# VBS - Obtenir la liste des fichiers et générer un CSV

> Besoin d'une liste de fichiers au format CSV ? Utilisez ce VBScript pour scanner un dossier, sous-dossiers inclus, et sortir les détails des fichiers comme la taille, la date et le propriétaire pour une analyse facile.

---
![VBS - Obtenir la liste des fichiers et générer un CSV](/img/v2/vbs.webp)

**TL;DR**

Cet article partage un VBScript (`files2csv.vbs`) qui parcourt récursivement un dossier Windows et exporte les détails des fichiers — chemin, nom, dates de création/d'accès/de modification, taille, type et propriétaire — vers un fichier CSV, prêt à être analysé dans Excel ou avec Python/Pandas.

Il y a six ans, j'avais besoin d'un script DOS capable de récupérer la liste de tous les fichiers d'un dossier sur une machine Windows et de générer un fichier `.csv` avec cette liste.

Une fois le fichier `.csv` généré, je pouvais le traiter dans MS Excel, par exemple, et le trier/filtrer ou, pourquoi pas, dans Python avec [la librairie Pandas](/blog/python-pandas-merge).

Voici ce que produit ce script : un fichier CSV listant tous les fichiers d'un dossier, avec les dates, la taille, le type et le propriétaire.

```csv
"FilePathAndName";"ParentFolder";"Name";"DateCreated";"DateLastAccessed";"DateLastModified";"Size";"Type";"Suffix";"Owner";
"C:\temp\test\test.csv";"C:\temp\test";"test.csv";"21-01-24 09:07:44";"21-01-24 09:09:08";"21-01-24 09:09:08";"472";"CSV Microsoft Excel File";"csv";"Christophe";
"C:\temp\test\test.vbs";"C:\temp\test";"test.vbs";"21-01-24 08:43:49";"21-01-24 09:09:03";"21-01-24 09:09:03";"3246";"VBScript File";"vbs";"Christophe";
```

Voici le script qui le génère. Copiez/collez la source ci-dessous et enregistrez-la dans un fichier, disons `c:\files2csv.vbs`. Ouvrez une console DOS, lancez `cd c:\` puis `cscript files2csv.vbs`. Quand le travail est terminé, vous obtenez le listing dans `files2csv.csv`.

**files2csv.vbs**

```vbs
'------------------------------------------------------------
'
' Get the list of files of the current folder + sub-folders and
' generate a .csv file with file information like path, size,
' extensions, author, ... making then easy to work with that list
' in Excel
'
' Based on a script of
' @author Peter Pinchao Liu (https://github.com/lpcclown)
' then modified by Christophe Avonture
'
' @Link : https://github.com/lpcclown/fileScan
'
'------------------------------------------------------------

Option Explicit

Dim objFSO, objCSVFile

' ------------------------------------
' Loop all file under one folder
' ------------------------------------
Function FilesTree(sPath)

Dim objFolder, objSubFolders, objSubFolder, objFiles, objFile
Dim objShell
Dim strFileName

  Set objFolder = objFSO.GetFolder(sPath)
  Set objSubFolders = objFolder.SubFolders
  Set objFiles = objFolder.Files

  For Each objFile In objFiles
    objCSVFile.Write chr(34) & objFile.Path & chr(34) & ";"
    objCSVFile.Write chr(34) & objFile.ParentFolder & chr(34) & ";"
    objCSVFile.Write chr(34) & objFile.Name & chr(34) & ";"
    objCSVFile.Write chr(34) & objFile.DateCreated & chr(34) & ";"
    objCSVFile.Write chr(34) & objFile.DateLastAccessed & chr(34) & ";"
    objCSVFile.Write chr(34) & objFile.DateLastModified & chr(34) & ";"
    objCSVFile.Write chr(34) & objFile.Size & chr(34) & ";"
    objCSVFile.Write chr(34) & objFile.Type & chr(34) & ";"
    objCSVFile.Write chr(34) & objFSO.getextensionname(objFile.Path) & chr(34) & ";"

    ' Get file owner
    Set objShell = CreateObject ("Shell.Application")
    Set objFolder = objShell.Namespace (sPath)

    For Each strFileName in objFolder.Items
      if objFolder.GetDetailsOf (strFileName, 0) = objFile.Name Then
        objCSVFile.Write chr(34) & objFolder.GetDetailsOf (strFileName, 10) & chr(34) & ";"
      End If
    Next

    objCSVFile.Writeline

  Next

  For Each objSubFolder In objSubFolders
    FilesTree(objSubFolder.Path) ' Recursion
  Next

  Set objFiles = Nothing
  Set objSubFolders = Nothing
  Set objFolder = Nothing

End Function

Dim sResultFileName, sFolderName
Dim wshShell

Const ForWriting = 2

  ' Create new CSV file : same name of this script but with
  ' .csv extension
  sResultFileName = wScript.ScriptFullName
  sResultFileName = replace(sResultFileName, ".vbs", ".csv")

  Set objFSO = CreateObject("Scripting.FileSystemObject")
  Set objCSVFile = objFSO.CreateTextFile(sResultFileName, ForWriting, True)

  ' Write comma delimited list of columns in new CSV file.
  objCSVFile.Write chr(34) & "FilePathAndName" & chr(34) & ";" & _
  chr(34) & "ParentFolder" & chr(34) & ";" & _
  chr(34) & "Name" & chr(34) & ";" & _
  chr(34) & "DateCreated" & chr(34) & ";" & _
  chr(34) & "DateLastAccessed" & chr(34) & ";" & _
  chr(34) & "DateLastModified" & chr(34) & ";" & _
  chr(34) & "Size" & chr(34) & ";" & _
  chr(34) & "Type" & chr(34) & ";" & _
  chr(34) & "Suffix" & chr(34) & ";" & _
  chr(34) & "Owner" & chr(34) & ";"

  objCSVFile.Writeline

  Set wshShell = CreateObject("WScript.Shell")
  sFolderName = wshShell.CurrentDirectory
  Set wshShell = Nothing

  wScript.echo "Scan the " & sFolderName & ", please wait..."
  wScript.echo ""

  FilesTree(sFolderName)

  wScript.echo "Done, file " & sResultFileName & " has been created"
```

> **Vous aviez besoin d'un séparateur tabulation ?:**
>
> Si oui, faites simplement un rechercher/remplacer pour changer `";"` en `vbTab` partout.


---

<!--
  canonical-url: https://www.avonture.be/fr/blog/vba-excel-ribbon-load
  published:     2025-02-22
  This is a static plain-Markdown mirror generated at build time.
  Visit the canonical URL above for the fully rendered page, with images and interactive components.
-->

# MS Office - Charger une liste déroulante depuis une plage Excel

> Chargez une plage Excel dans votre contrôle liste déroulante d'un ruban VBA personnalisé. Ce tutoriel pas à pas couvre le code VBA, le XML Custom UI et les plages nommées nécessaires à une solution dynamique.

---
![MS Office - Charger une liste déroulante depuis une plage Excel](/img/v2/ribbon.webp)

**TL;DR**

Apprenez à créer un menu déroulant dynamique dans un ruban Excel personnalisé, alimenté par les valeurs d'une plage de feuille de calcul. Ce guide pas à pas vous accompagne sur tout le processus : nommer votre plage de données dans Excel, définir la disposition du ruban en XML avec le Custom UI Editor, et écrire les fonctions de callback VBA nécessaires pour charger les éléments, gérer la sélection et écrire la valeur choisie dans une cellule précise. Cette technique permet des interfaces souples et agréables dans vos projets VBA.

Dans cet article, nous allons voir comment charger très facilement une plage Excel dans un ruban et l'afficher dans une liste déroulante. *Si vous n'avez encore jamais construit de ruban personnalisé, commencez par [MS Office - How to create a ribbon in Excel](/blog/vba-excel-ribbon).*

L'idée est de proposer une liste de valeurs dans un ruban sans devoir coder ces valeurs en dur : il suffit de pointer vers une plage, n'importe où dans votre classeur.

J'ai utilisé cette technique dans beaucoup de mes applications Excel (c.-à-d. des fichiers Excel contenant du code VBA).

Pour cet article, nous allons créer une liste de périodes (YYYYMM) dans une feuille de calcul et charger cette liste dans notre ruban personnalisé.

De cette façon, nous pouvons offrir une meilleure expérience utilisateur en proposant une liste et en exécutant, par exemple, [une requête vers une base de données](/blog/vba-excel-sql-server-part-2) pour récupérer les données de cette période (ou tout autre traitement).

Voici le résultat : la liste déroulante chargée directement depuis la plage de la feuille, et la valeur sélectionnée réécrite dans une cellule.

![Demo](./images/demo.webp)

## Pourquoi ça fonctionne {#why-it-works}

* Les éléments de la liste déroulante proviennent d'une **plage nommée** (`_rngParamsPeriod`), pas de valeurs codées en dur dans le XML — modifiez la plage dans la feuille et la liste du ruban suit.
* Un callback VBA (`getItemCount`, déclaré dans le XML du ruban) fait la lecture ; sélectionner une valeur dans le ruban l'écrit directement dans une cellule nommée (`_Period`) ailleurs dans le classeur.

## C'est parti {#lets-play}

Créez d'abord un classeur vide. Créez ensuite une nouvelle feuille appelée par exemple `Params` avec une liste de valeurs. Pour cet article, créons une liste de périodes :

![The range](./images/range.webp)

Rien de compliqué pour l'instant. Pour rester souple, sélectionnez la plage et nommez-la : `_rngParamsPeriod`. C'est quand même mieux que de coder en dur une plage comme `$A$2:$A$14`, non ?

La deuxième chose à faire est de prévoir une cellule dans votre feuille où la valeur sélectionnée sera écrite : quand l'utilisateur choisit une valeur dans la liste, nous allons demander à Excel d'y placer la valeur sélectionnée. Pour cela, cliquez sur la cellule où vous souhaitez voir la période sélectionnée et nommez cette cellule `_Period`. Sur l'image ci-dessous, je choisis la cellule `$C$2` dans la même feuille, mais elle peut se trouver ailleurs.

![The period range](./images/selected_period.webp)

Il est temps d'enregistrer votre fichier Excel une première fois, disons dans `c:\temp\ribbon.xlsx`, puis de fermer le classeur.

## Ajouter un ruban {#adding-a-ribbon}

Passons à l'ajout de notre ruban. Pour cela, téléchargez cet outil gratuit : <https://bettersolutions.com/vba/ribbon/custom-ui-editor-download.htm>. Vous y trouverez un exécutable appelé `CustomUIEditor.exe`. Double-cliquez dessus pour démarrer l'éditeur puis ouvrez votre fichier `c:\temp\ribbon.xlsx` :

![Custom UI editor](./images/editor.webp)

Cliquez sur le menu Insert puis sélectionnez `Office 2010 Custom UI Part`.

Collez le XML ci-dessous dans la fenêtre de l'éditeur :

**customui.xml**

```xml
<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui">
  <ribbon>
    <tabs>
      <tab id="demoRibbon" label="demo Ribbon" insertBeforeMso="TabHome">
        <group id="grpParams" label="Parameters">
          <dropDown id="paramsCbxPeriod" label="Period" screentip="Select the period" supertip="Please select the period..." onAction="modToolbar_cbxPeriod.onAction" getSelectedItemID="modToolbar_cbxPeriod.getSelectedItemID" getItemLabel="modToolbar_cbxPeriod.getItemLabel" getItemID="modToolbar_cbxPeriod.getItemID" getItemCount="modToolbar_cbxPeriod.getItemCount"/>
        </group>
      </tab>
    </tabs>
  </ribbon>
</customUI>
```

Vous obtiendrez ceci :

![Custom UI editor](./images/xml.webp)

Enregistrez vos modifications et quittez l'éditeur.

## Place à notre code VBA {#time-to-add-our-vba-code}

Depuis l'explorateur, double-cliquez sur votre fichier `c:\temp\ribbon.xlsx` pour démarrer Excel et rouvrir le classeur.

Vous obtiendrez un message d'erreur et c'est parfaitement normal : il nous reste du code VBA à ajouter. Cliquez simplement sur **Ok**.

![Error](./images/missing_code.webp)

> **Information:**
>
> Dans notre ruban, nous avons écrit, entre autres, ceci : `getItemCount="modToolbar_cbxPeriod.getItemCount"`. Excel essaie donc d'exécuter une fonction appelée `getItemCount` depuis un module appelé `modToolbar_cbxPeriod` et… il n'existe pas encore.

Appuyez sur `ALT`-`F11` pour ouvrir l'éditeur VBE.

Comme illustré ci-dessous, faites un clic droit sur le projet `VBEProject` et insérez un nouveau module.

![Inserting a new module](./images/insert_module.webp)

Cela fait, cliquez sur le module ajouté et, en bas à gauche, donnez-lui un nom, par exemple `modToolbar_cbxPeriod`.

Dans la partie principale de l'écran, à droite, collez ce code :

**module.bas**

```bas
Option Base 0
Option Compare Text

' Name of the range in the workbook, with the list of periods
Private Const cRangeName = "_rngParamsPeriod"

' When a period will be selected from the ribbon, a "name"
' will be created in the active workbook so, in a cell formula,
' it's possible to retrieve the selected value.
' Formula example :
'     = "Selected period is " & _Period
Private Const cName = "_Period"

Private sValue As String

' -------------------------------------------------------------
'
' Initialization, define default value : select the last value
' of the range
'
' -------------------------------------------------------------

Public Sub Initialize()

Dim wLastIndex As Byte

    ' Get the last value of the range
    wLastIndex = shParams.Range(cRangeName).Rows.Count
    sValue = shParams.Range(cRangeName).Cells(wLastIndex, 1).Value

    ' Create / Update the name
    Range(cName).Value = sValue

End Sub

' -------------------------------------------------------------
'
' Return the selected value to the calling code.
'
' For instance, from within a VBA module just call
'    Msgbox modToolbar_cbxPeriod.GetValue()
'
' -------------------------------------------------------------

Public Function GetValue() As String
    GetValue = sValue
End Function

' -------------------------------------------------------------
'
' Remember the selected value : the user has selected a value from
' the ribbon
'
' -------------------------------------------------------------

Sub onAction(control As IRibbonControl, id As String, index As Integer)
    sValue = id

    Range(cName).Value = sValue

    ' Optional, inform the user in the Excel's statusbar
    Application.StatusBar = "Set to [" & sValue & "]"
End Sub

' -------------------------------------------------------------
'
' Return the number of entries for the combobox
'
' -------------------------------------------------------------

Sub getItemCount(control As IRibbonControl, ByRef returnedVal)
    returnedVal = shParams.Range(cRangeName).Rows.Count
End Sub

' -------------------------------------------------------------
'
' Set the ID for each entry (the ID can be different of the displayed caption)
'
' -------------------------------------------------------------

Public Sub getItemID(control As IRibbonControl, index As Integer, ByRef id)
    id = shParams.Range(cRangeName).Cells(index + 1, 1).Value
End Sub

' -------------------------------------------------------------
'
' Define the label (the caption) of each entry in the list
'
' -------------------------------------------------------------

Public Sub getItemLabel(control As IRibbonControl, index As Integer, ByRef returnedVal)
    returnedVal = shParams.Range(cRangeName).Cells(index + 1, 1).Value
End Sub

' -------------------------------------------------------------
'
' Get the default value for the combobox
'
' -------------------------------------------------------------

Public Sub getSelectedItemID(control As IRibbonControl, ByRef id)
    id = sValue
End Sub
```

Nous y sommes presque : il faut donner un nom à la feuille où se trouve la plage. Si vous vous souvenez du début de cet article, nous avons créé la plage dans une feuille appelée `Params`. Dans l'éditeur VBE, sélectionnez donc la feuille `Params` comme illustré ci-dessous (voir 1.) et nommez la feuille `shParams` (voir 2).

![Naming the sheet](./images/shParams.webp)

> **Vous devez maintenant utiliser l'extension .xlsm:**
>
> Enregistrez le classeur Excel mais, cette fois, avec l'extension `.xlsm` puisqu'il contient du code VBA.

Testons notre fonctionnalité : fermez le classeur et rouvrez-le. Cette fois, votre liste est remplie et, en sélectionnant une valeur, celle-ci sera injectée dans votre feuille de calcul, prête à être utilisée — exactement le résultat montré en début d'article.

## Conclusion {#conclusion}

Une plage nommée, un peu de XML Custom UI et un module de callback VBA : voilà toute la recette d'une liste déroulante de ruban dont les valeurs ne seront plus jamais codées en dur — modifiez la plage, et tous les classeurs qui utilisent ce ruban suivent. [Envie de continuer à jouer avec les rubans ? Jetez un œil à mes autres articles sur le sujet.](/blog/vba-excel-ribbon)


---

<!--
  canonical-url: https://www.avonture.be/fr/blog/vba-access-export
  published:     2025-06-27
  This is a static plain-Markdown mirror generated at build time.
  Visit the canonical URL above for the fully rendered page, with images and interactive components.
-->

# Exporter les objets MS Access

> Versionnez facilement votre base de données MS Access ! Exportez tout le code VBA, les formulaires, modules, requêtes et rapports vers des fichiers plats grâce à un simple script VBS, prêt pour GitHub.

---
![Exporter les objets MS Access](/img/v2/msaccess.webp)

**TL;DR**

Cet article présente un script VBS qui exporte tous les objets — formulaires, modules, requêtes, rapports et macros — d'une base de données Microsoft Access vers des fichiers texte individuels. Les développeurs peuvent ainsi versionner facilement le code source de leur application Access avec des outils comme Git et GitHub. Le script organise automatiquement les fichiers exportés dans un dossier `src` structuré, en créant un fichier distinct par objet. Suivre les changements et conserver un historique de la conception et de la logique de la base devient simple.

Il y a longtemps, dans une vie antérieure, j'ai développé beaucoup de bases de données MS Access et, contrairement aux outils modernes, il n'était pas possible de versionner le code (modules, macros, requêtes, etc.) dans un outil comme GitHub.

Ces objets font partie intégrante de la base de données, au même titre que les tables et leurs données. Tout est stocké dans le format `.mdb` (ou `.mda` ou `.accdb`). Si vous voulez les versionner, vous devez d'abord les extraire.

*Deux autres articles MS Access sur ce blog : [VBS - Retrieve the list of fields in a MS Access Database](/blog/vbs-msaccess-get-fields) pour auditer la structure, et [How to optimize an existing MS Access database](/blog/msaccess-optimize) pour agir sur les résultats.*

Voyons comment faire.

## Exemple {#sample}

En lançant `cscript vbs_access_export.vbs C:\Christophe\db1.mdb` dans une console DOS, vous obtiendrez ceci :

```bash
Process database C:\Christophe\db1.mdb

Exporting sources to C:\Christophe\src\db1.mdb\

Export all forms
        Export form 1/2 - frmCustomers to Forms\frmCustomers.frm
        Export form 2/2 - frmInvoices to Forms\frmInvoices.frm

Export all macros
        Export macro 1/15 - mcrPrint to Macros\mcrPrint.txt
        [...]

Export all modules
        Export module 1/2 - Helper to Modules\Helper.bas
        Export module 2/2 - SQL_Server to Modules\SQL_Server.bas

Export all queries
        Export query 1/23 - qryCustomers to Queries\qryCustomers.sql
        Export query 2/23 - qryInvoices to Queries\qryInvoices.sql
        [...]

Export all reports
        Export report 1/8 - Invoice to Reports\Invoice.txt
        [...]
```

Une fois terminé, vous aurez un sous-dossier `src` avec un fichier par objet : indirectement, vous disposez donc d'une sauvegarde de votre code 👌.

## Description {#description}

Mon script VBS <https://github.com/cavo789/vbs_access_export> exporte tous les objets de code (formulaires, macros, modules, requêtes et rapports) d'une base de données / application MS Access vers des fichiers plats sur votre disque.

Vous obtenez ainsi une sauvegarde rapide de votre code et vous pouvez le synchroniser sur une plateforme de versioning comme GitHub.

Le script démarre MS Access (en mode caché), ouvre la base spécifiée, traite chaque objet de code et les exporte un par un dans un dossier `\src\your_database.mdb`.

Le dossier `src` est créé automatiquement si nécessaire et vous y trouverez un sous-dossier portant le même nom que votre fichier (vous pouvez donc avoir plusieurs fichiers exportés dans le même dossier `src`).

## Installation {#install}

Récupérez simplement une copie du script VBS <https://github.com/cavo789/vbs_access_export>, et éventuellement le `.cmd` aussi (pour vous faciliter la vie), puis enregistrez-les dans le même dossier que votre base de données.

## Utilisation {#usage}

Éditez le fichier `.cmd` et vous verrez comment ça fonctionne : il suffit de lancer le `.vbs` avec un seul paramètre, le nom de votre base de données — la même commande que celle montrée en début d'article.

## Conclusion {#conclusion}

Un seul script VBS transforme formulaires, modules, requêtes, rapports et macros — tout ce qui vivait uniquement dans le fichier `.mdb`/`.accdb` — en fichiers plats que vous pouvez committer sur GitHub, comparer et suivre comme n'importe quelle autre base de code. Vous travaillez souvent avec des fichiers bourrés de VBA ? Voyez aussi [MS Excel - Get the list of references used in your modules](/blog/vba-excel-list-references), [How to optimize an existing MS Access database](/blog/msaccess-optimize) et [VBS - Retrieve the list of fields in a MS Access Database](/blog/vbs-msaccess-get-fields).


---

<!--
  canonical-url: https://www.avonture.be/fr/blog/vba-excel-list-references
  published:     2025-10-27
  This is a static plain-Markdown mirror generated at build time.
  Visit the canonical URL above for the fully rendered page, with images and interactive components.
-->

# MS Excel - Obtenir la liste des références utilisées dans vos modules

> Développeur VBA ? Arrêtez de vérifier les références à la main ! Utilisez ce script VBS pour récupérer automatiquement la liste de toutes les références VBA dans plusieurs fichiers Excel .xlsm ou .xlam.

---
![MS Excel - Obtenir la liste des références utilisées dans vos modules](/img/v2/vba_export_xlsm.webp)

**TL;DR**

Cet article présente un script VBS qui automatise la récupération des références VBA dans plusieurs fichiers Excel `.xlsm` ou `.xlam`. Plutôt que de vérifier chaque classeur à la main, il suffit de lancer un simple script `run.vbs` dans le dossier cible. Le script ouvre les fichiers, désactive les macros et affiche la liste de toutes les références trouvées.

Vous êtes développeur VBA et vous avez créé beaucoup de classeurs Excel `.xlsm` (ou `.xlam`), c'est-à-dire des fichiers contenant des modules VBA — pensez à ceux construits dans [MS Office - How to create a ribbon in Excel](/blog/vba-excel-ribbon) ou [MS Excel - Connect to a SQL Server database](/blog/vba-excel-sql-server-part-2).

Comment récupérer la liste des références utilisées par un de vos fichiers ? Bien sûr, vous pouvez ouvrir le classeur, ouvrir l'éditeur VBE, cliquer sur le menu `Tools` puis `References` pour obtenir la boîte de dialogue avec la liste des références. Oui, c'est possible.

Ou vous pouvez utiliser mon script <https://github.com/cavo789/vbs_xls_list_references> pour automatiser ça — le même genre de petit script d'automatisation VBS que dans [Export MS Access objects](/blog/vba-access-export).

Voici ce que vous obtenez, pour chaque fichier `.xlam` ou `.xlsm` d'un dossier :

```bash
Processing files in C:\Christophe

Get the list of references used in C:\Christophe\Application.xlsm

    Name My_AddIn
    Full Path: C:\Christophe\My_Addin\My_AddIn.xlam

    Name A_Second_AddIn
    Full Path: C:\Christophe\A_Second_AddIn\A_Second_AddIn.xlam

Get the list of references used in C:\Christophe\Invoices.xlam

    Name My_AddIn
    Full Path: C:\Christophe\My_Addin\My_AddIn.xlam
```

Repérez un dossier sur votre disque dur contenant un ou plusieurs fichiers `.xlam` ou `.xlsm`.

Créez-y simplement un fichier appelé `run.vbs` et copiez/collez le code ci-dessous dedans :

**run.vbs**

```vbs

' -----------------------------------------------------------------
' Author: Christophe AVONTURE
' Date	: January 2019
'
' Retrieve the list of references used in an Excel file
' (.xlam files f.i.) and display them on the console.
' Loop and process all Excel files in the current folder

' @src https://github.com/cavo789/vbs_xls_list_references
' -----------------------------------------------------------------

Option Explicit

Class clsMSExcel

    Private oApplication
    Private sFileName
    Private bVerbose, bEnableEvents, bDisplayAlerts
    Private bAppHasBeenStarted
    Private objFSO

    Public Property Let verbose(bYesNo)
        bVerbose = bYesNo
    End Property

    Public Property Let EnableEvents(bYesNo)
        bEnableEvents = bYesNo

        If Not (oApplication Is Nothing) Then
            oApplication.EnableEvents = bYesNo
        End if
    End Property

    Public Property Let DisplayAlerts(bYesNo)
        bDisplayAlerts = bYesNo

        If Not (oApplication Is Nothing) Then
            oApplication.DisplayAlerts = bYesNo
        End if

    End Property

    Public Property Let FileName(ByVal sName)
        sFileName = sName
    End Property

    Public Property Get FileName
        FileName = sFileName
    End Property

    Private Sub Class_Initialize()

        bVerbose = False
        bAppHasBeenStarted = False
        bEnableEvents = False
        bDisplayAlerts = False

        Set oApplication = Nothing

        Set objFSO = CreateObject("Scripting.FileSystemObject")
    End Sub

    Private Sub Class_Terminate()

        oApplication.EnableEvents = True
        oApplication.DisplayAlerts = True

        Set oApplication = Nothing
        Set objFSO = Nothing

    End Sub

    ' --------------------------------------------------------
    ' Initialize the oApplication object variable : get a pointer
    ' to the current Excel.exe app if already in memory or start
    ' a new instance.
    '
    ' If a new instance has been started, initialize the variable
    ' bAppHasBeenStarted to True so the rest of the script knows
    ' that Excel should then be closed by the script.
    ' --------------------------------------------------------
    Public Function Instantiate()

        If (oApplication Is Nothing) Then

            On error Resume Next

            Set oApplication = GetObject(,"Excel.Application")

            If (Err.number <> 0) or (oApplication Is Nothing) Then
                Set oApplication = CreateObject("Excel.Application")
                ' Remember that Excel has been started by
                ' this script ==> should be released
                bAppHasBeenStarted = True
            End If

            oApplication.EnableEvents = bEnableEvents
            oApplication.DisplayAlerts = bDisplayAlerts

            Err.clear

            On error Goto 0

        End If

        ' Return True if the application was created right
        ' now
        Instantiate = bAppHasBeenStarted

    End Function

    Public Sub Quit()
        If not (oApplication Is Nothing) Then
            oApplication.Quit
        End If
    End Sub

    ' --------------------------------------------------------
    ' Open a standard Excel file and allow to specify if the
    ' file should be opened in a read-only mode or not
    ' --------------------------------------------------------
    Public Sub Open(bReadOnly)

        If not (oApplication Is nothing) Then

            If bVerbose Then
                wScript.echo "Open " & sFileName & _
                    " (clsMSExcel::Open)"
            End If

            ' False = UpdateLinks
            oApplication.Workbooks.Open sFileName, False, _
                bReadOnly

        End If

    End sub

    ' --------------------------------------------------------
    ' Close the active workbook
    ' --------------------------------------------------------
    Public Sub CloseFile()

        Dim wb
        Dim I
        Dim sBaseName

        If Not (oApplication Is Nothing) Then

            If bVerbose Then
                wScript.echo "Close " & FileName & " (clsMSExcel::CloseFile)"
            End if

            ' Only the basename and not the full path
            sBaseName = objFSO.GetFileName(FileName)

            On Error Resume Next
            Set wb = oApplication.Workbooks(sBaseName)
            If Not (err.number = 0) Then
                ' Not found, workbook not loaded
                Set wb = Nothing
            Else
                If bVerbose Then
                    wScript.echo "	Closing " & sBaseName & " (clsMSExcel::CloseFile)"
                End if

                ' Close without saving
                wb.Close False

            End if

            On Error Goto 0

        End If

    End Sub

    ' --------------------------------------------------------
    ' Display the list of references used by the file
    ' --------------------------------------------------------
    Public Sub References_ListAll()

        Dim wb, ref
        Dim bShow, bEmpty

        If Not (oApplication Is Nothing) Then

            Set wb = oApplication.Workbooks(objFSO.GetFileName(sFileName))
            bEmpty = True

            If Not (wb Is Nothing) Then

                For Each ref In wb.VBProject.References

                    bShow = (LCase(Right(ref.FullPath,5)) = ".xlam")

                    If bShow then

                        bEmpty = False

                        wScript.echo "    Name " & ref.Name
                        'wScript.echo "    Built In: " & ref.BuiltIn
                        wScript.echo "    Full Path: " & ref.FullPath
                        'wScript.echo "     Is Broken: " & ref.IsBroken
                        'wScript.echo "    Version: " & ref.Major & "." & ref.Minor
                        wScript.echo ""

                    End If
                Next
            End If

            If bEmpty Then
                wScript.echo "    The file didn't use references"
                wScript.echo ""
            End If

            Set wb = Nothing

        End If
    End sub

End Class

' ----------------------------------------------------------
' When the user double-click on a .vbs file (from Windows explorer f.i.)
' the running process will be WScript.exe while it's CScript.exe when
' the .vbs is started from the command prompt.
'
' This subroutine will check if the script has been started with cscript
' and if not, will run the script again with cscript and terminate the
' "wscript" version. This is useful when the script generate a lot of
' wScript.echo statements, easier to read in a command prompt.'
' ----------------------------------------------------------
Sub ForceCScriptExecution()

    Dim sArguments, Arg, sCommand

    If Not LCase(Right(WScript.FullName, 12)) = "\cscript.exe" Then

        ' Get command lines parameters'
        sArguments = ""
        For Each Arg In WScript.Arguments
            sArguments=sArguments & Chr(34) & Arg & Chr(34) & Space(1)
        Next

        sCommand = "cmd.exe cscript.exe //nologo " & Chr(34) & _
        WScript.ScriptFullName & Chr(34) & Space(1) & Chr(34) & sArguments & Chr(34)

        ' 1 to activate the window
        ' true to let the window opened
        Call CreateObject("Wscript.Shell").Run(sCommand, 1, true)

        ' This version of the script (started with WScript) can be terminated
        wScript.quit

    End If

End Sub

' ------------------------------------------------------
' Get the current folder
'
' Use the wScript.ScriptFullName and not the
' wshShell.CurrentDirectory property to make the folder dependant of
' where the script is located since the script can be fired with, f.i.,
' c:\temp > cscript i:\folder\app.vbs.
' We wish to get "i:\folder"
' ------------------------------------------------------
Public Function CurrentFolder

    Dim objFSO, objFile

    Set objFSO = CreateObject("Scripting.FileSystemObject")
    Set objFile = objFSO.GetFile(wScript.ScriptFullName)

    CurrentFolder = objFSO.GetParentFolderName(objFile)

    ' Be sure to have the final slash
    If Not (Right(CurrentFolder, 1) = "\") THen
        CurrentFolder = CurrentFolder & "\"
    End If

    Set objFile = Nothing
    Set objFSO = Nothing

End Function

Dim cMSExcel
Dim sCurrentFolder, sFiles, sFile, sExt
Dim arrFiles
Dim objFSO, objFolder, objFiles, objFile
Dim I

    Call ForceCScriptExecution

    sCurrentFolder = CurrentFolder()

    sFiles = ""

    Set objFSO = CreateObject("Scripting.FileSystemObject")

    ' Get the list of files present in the current folder
    Set objFolder = objFSO.GetFolder(sCurrentFolder)
    Set objFiles = objFolder.Files

    ' Loop every files
    For Each objFile In objFiles

        ' Don't process files starting with ~ since Excel use such
        ' filename for files already opened
        If Not (Left(objFile.Name, 1) = "~") Then

            sExt = LCase(objFSO.getExtensionName(objFile.Name))

            ' Process only xlsx files
            If (sExt = "xlsm") or (sExt = "xlam") Then
                ' Just concatenate the filename with a delimiter
                sFiles = sFiles & objFile.Name & "#"
            End If

        End If

    Next

    If (Right(sFiles, 1) = "#") Then
        sFiles = Left(sFiles, Len(sFiles) -1)
    End If

    ' No more needed, release objects
    Set objFile = Nothing
    Set objFiles = Nothing
    Set objFolder = Nothing
    Set objFSO = Nothing

    ' sFiles is a string that contains the list of files we need to process
    ' Like f.i. "file1.xlsx#file2.xlsx#file3.xlsx"
    ' Explode the string into an array
    If (Not (sFiles = "")) Then

        ' We've at least one file to process
        wScript.echo "Processing files in " & sCurrentFolder
        wScript.echo " "

        arrFiles=Split(sFiles, "#")

        If (isArray(arrFiles)) Then

            Set cMSExcel = New clsMSExcel
            cMSExcel.Verbose = False
            cMSExcel.EnableEvents = False

            cMSExcel.Instantiate

            For I = 0 To UBound(arrFiles)

                sFile = sCurrentFolder & arrFiles(I)

                wScript.echo "Get the list of references used in " & sFile
                wScript.echo ""

                cMSExcel.FileName = sFile

                Call cMSExcel.Open(True)
                Call cMSExcel.References_ListAll()
                Call cMSExcel.CloseFile()

            Next

            cMSExcel.Quit
            Set cMSExcel = Nothing

        End If

    Else

        wScript.echo "The folder " & sCurrentFolder & " doesn't contains any Excel file"
        wScript.echo " "

    End If
```

Maintenant, ouvrez une console DOS ou Powershell, allez dans ce dossier et lancez `cscript run.vbs`. C'est tout. Le script va récupérer tous les fichiers `.xlam` ou `.xlsm` et automatiser l'ouverture d'Excel, l'ouverture du fichier (en désactivant l'exécution des macros) et la récupération de la liste des références — la même sortie que celle montrée en haut de cet article.


---