ACC : Utilisation de Microsoft Access comme serveur Automation

Traductions disponibles Traductions disponibles
Numéro d'article: 147816 - Voir les produits auxquels s'applique cet article
Ancien nº de publication de cet article : F147816
Agrandir tout | Réduire tout

Sommaire

Résumé

Niveau avancé : Connaissances approfondies requises en codage, interopérabilité et environnements multi-utilisateurs.

Cet article fournit des informations sur l'utilisation de Microsoft Access 7.0 ou 97 comme serveur Automation, ainsi que des exemples d'utilisation. Dans Visual Basic pour Applications, vous pouvez manipuler la fonctionnalité de Microsoft Access à partir d'un contrôleur (ou client) prenant en charge Automation, tel que Microsoft Excel, Microsoft Project ou Microsoft Visual Basic. Par exemple, dans Microsoft Excel, vous pouvez créer une application qui utilise Automation pour imprimer un état dans une base de données Microsoft Access.

Cet article s'adresse aux utilisateurs possédant une certaine expérience de Visual Basic pour Applications et de la création d'applications Microsoft Access à l'aide des outils de programmation fournis avec Microsoft Access. Pour plus d'informations sur Visual Basic pour Applications, consultez votre manuel " Création d'applications à l'aide de Microsoft Access ".

Plus d'informations

Cet article s'articule autour des rubriques suivantes :

  • Création d'une référence à Microsoft Access
  • Utilisation des fonctions GetObject() et CreateObject()
  • Présentation des propriétés UserControl et Visible
  • Affichage d'une instance de Microsoft Access
  • Fermeture d'une instance de Microsoft Access
  • Contournement des paramètres de démarrage lors de l'ouverture d'une base de données
  • Appel de fonctions Microsoft Access
  • Appel de procédures personnalisées
  • Utilisation d'une application exécutable
  • Utilisation d'un groupe de travail sécurisé
  • Exemples:

    • Aperçu ou impression d'un état
    • Appel d'un Assistant État pour la création d'un nouvel état

Création d'une référence à Microsoft Access

Automation vous permet de contrôler et de manipuler des objets Microsoft Access à partir d'autres applications en utilisant le code Visual Basic. À cet effet, des informations sur les objets Microsoft Access sont stockées dans un type de bibliothèque nommé Msaccess.tlb. Pour optimiser les performances de votre code OLE Automation, vous pouvez créer une référence au type de bibliothèque Microsoft Access.

REMARQUE : Plusieurs des exemples de procédures présentés dans cet article requièrent une référence à Microsoft Access. Si vous voulez utiliser les exemples de code fournis, vous devez suivre les étapes suivantes pour créer une référence dans votre contrôleur Automation.

Pour créer une référence :

  1. Ouvrez un module dans votre contrôleur Automation.
  2. Dans le menu Outils, cliquez sur Références.
  3. Dans la zone Références, sélectionnez Microsoft Access 8.0 object Library (ou Microsoft Access pour Windows 95 dans la version 7.0), puis cliquez sur OK.
Il n'est pas nécessaire de créer une référence à Microsoft Access pour pouvoir manipuler ses objets à l'aide d'Automation. Toutefois, la création d'une référence présente les avantages suivants :

  • Votre code sera exécuté plus rapidement.
  • Vous pouvez utiliser l'explorateur d'objets pour afficher tous les objets, propriétés et méthodes Microsoft Access. Cet outil vous aide à déterminer les propriétés et méthodes disponibles pour chaque objet.
  • Vous pouvez utiliser des constantes Microsoft Access ou appeler directement des fonctions Microsoft Access dans votre code Visual Basic.
  • Vous pouvez déclarer une variable comme type d'objet défini par l'application, comme par exemple :
     Dim objAccess As Access.Application 
    Ce type de déclaration, nommé liaison anticipée, est la plus rapide. Toutefois, elle n'est pas prise en charge par tous les contrôleurs Automation. Pour cette raison, l'exemple de code contenu dans cet article utilise la liaison tardive au lieu de la liaison anticipée. Par exemple, il déclare une variable comme objet plutôt que comme Access.Application :
     Dim objAccess As Object 
    Pour savoir si une application prend en charge la liaison anticipée ou tardive, consultez la documentation de votre contrôleur Automation.

Utilisation des fonctions GetObject() et CreateObject()

Les fonctions GetObject() et CreateObject() vous permettent d'ouvrir ou d'activer une instance de Microsoft Access et de contrôler sa fonctionnalité à partir d'une application de contrôleur Automation. Lorsque vous utilisez ces fonctions dans un module Visual Basic, vous activez Microsoft Access en tant qu'objet Automation et vous assignez l'objet à une variable. Vous trouverez ci-dessous plusieurs exemples d'utilisation des fonctions GetObject() et CreateObject().

Méthode 1

Vous pouvez utiliser la fonction GetObject() pour activer ou ouvrir une instance de Microsoft Access et une base de données spécifique à l'aide de la syntaxe suivante :
 Dim objAccess as Object
 Set objAccess = GetObject("C:\Program Files\Microsoft
 Office\Office\Samples\Comptoir.mdb") 
Sachez que la variable objAccess peut faire référence à des instances différentes de Microsoft Access, selon les conditions présentes lors de l'exécution du code, comme suit :

  • Si la base de données spécifiée (Comptoir.mdb) est déjà ouverte dans une instance de Microsoft Access, objAccess se réfère à l'instance ouverte.
  • Si la base de données spécifiée est ouverte dans plusieurs instances de Microsoft Access, objAccess se réfère aléatoirement à l'une de ces instances.
  • Si Microsoft Access n'est pas actif lors de l'exécution du code, une nouvelle instance est ouverte et objAccess se réfère à celle-ci.

Méthode 2

Vous pouvez utiliser la fonction GetObject() pour activer une instance de Microsoft Access à l'aide de la syntaxe suivante :
 Dim objAccess as Object
 Set objAccess = GetObject(,"Access.Application") 
Sachez que la variable objAccess peut faire référence à des instances différentes de Microsoft Access, selon les conditions présentes lors de l'exécution du code, comme suit :

  • Si une instance de Microsoft Access est en cours lors de l'exécution du code, objAccess se réfère à l'instance ouverte.
  • Si plusieurs instances de Microsoft Access sont actives, objAccess se réfère aléatoirement à l'une de ces instances.
  • Si Microsoft Access n'est pas actif lors de l'exécution du code, une erreur s'affiche.

Méthode 3

Vous pouvez utiliser la fonction CreateObject() pour ouvrir une nouvelle instance de Microsoft Access à l'aide de la syntaxe suivante :
 Dim objAccess as Object
 Set objAccess = CreateObject("Access.Application") 
La variable objAccess fait référence à l'objet Application de la nouvelle instance.

REMARQUE : Certains contrôleurs Automation, tels que Microsoft Visual Basic 4.0, reconnaissent le mot-clé " New " comme autre méthode d'ouverture d'une nouvelle instance d'un serveur Automation, comme par exemple dans :
 Dim objAccess as New Access.Application 
Consultez la documentation de votre contrôleur Automation pour déterminer s'il prend en charge le mot-clé New.

Présentation des propriétés UserControl et Visible

Les propriétés UserControl et Visible de l'objet Application permettent de contrôler le comportement à l'écran de Microsoft Access. La propriété UserControl permet de déterminer si une instance de Microsoft Access a été démarrée par l'utilisateur ou par une autre application à l'aide d'Automation. La propriété Visible permet de déterminer si une instance de Microsoft Access est visible ou réduite.

Lors de l'ouverture ou de l'activation d'une instance de Microsoft Access, les propriétés UserControl et Visible sont définies automatiquement, selon que Microsoft Access est déjà actif ou non lors de l'activation d'un objet Application dans Visual Basic. Le tableau ci-dessous illustre ces paramètres dans divers scénarios :
 Méthode d'activation de MS Access      UserControl         Visible
 ------------------------------------------------------------------

 Fonction GetObject() après             Vrai                Vrai
 l'ouverture d'une instance 
 de Microsoft Access

 Fonction Shell()                       Vrai                Vrai

 Fonction GetObject()
 lorsqu'aucune                          Faux                Faux
 instance de Microsoft Access
 n'est encore ouverte

 Fonction CreateObject()                Faux                Faux

Propriété UserControl
 -------------------- 

Propriété UserControl

La propriété UserControl est toujours en lecture seule ; vous ne pouvez donc pas la définir à l'aide d'Automation. Toutefois, cette propriété peut être automatiquement modifiée si un utilisateur intervient alors que votre code Automation est inactif. Par exemple, la propriété UserControl devient fausse lorsque les événements suivants se produisent :

  1. L'utilisateur crée une instance de Microsoft Access, définissant la propriété UserControl sur Vrai.
  2. Vous exécutez le code Automation dans l'application contrôleur qui utilise la fonction GetObject() pour activer l'instance de Microsoft Access ouverte précédemment. La variable objet utilisée pour l'instance est une variable publique ou de niveau module.
  3. L'utilisateur restaure Microsoft Access à l'aide de la barre des tâches (ou la liste des tâches dans Windows NT).
  4. L'utilisateur tente de fermer Microsoft Access en cliquant sur le bouton Fermer. L'instance ne se ferme pas car le contrôleur Automation possède une variable publique ou de niveau module faisant référence à cette instance de Microsoft Access. L'instance est alors réduite en icône, ce qui définit les propriétés UserControl et Visible sur Faux.
De même, la propriété UserControl devient vraie lorsque les événements suivants se produisent :

  1. Vous créez une nouvelle instance de Microsoft Access à l'aide d'Automation. La propriété UserControl est fausse. La propriété Visible est également fausse et l'instance est donc réduite.
  2. L'utilisateur restaure l'instance à l'aide de la barre des tâches (ou la liste des tâches dans Windows NT). Vous pouvez aussi appeler la fonction ShowWindow () API dans Visual Basic pour restaurer l'instance, à l'aide de code. Dans les deux cas, les propriétés UserControl et Visible deviennent vraies.
Si la propriété UserControl est définie sur Vrai, ceci peut affecter votre capacité de contrôler le comportement à l'écran de Microsoft Access. Plus précisément, vous devez prendre garde aux limitations suivantes :

  • Un message d'erreur risque de s'afficher dans votre code Automation lorsque vous tentez de définir la propriété Visible sur Vrai ; la propriété Visible est en lecture seule lorsque la propriété UserControl est vraie.
  • Vous ne pouvez pas interrompre ou supprimer un message d'erreur généré par Microsoft Access comme application OLE Serveur. Si vous exécutez une commande incorrecte, comme par exemple tenter d'ouvrir un formulaire qui n'existe pas dans la base de données en cours, un message d'erreur s'affiche.
  • Une instance de Microsoft Access ne se ferme pas automatiquement lorsque la variable objet faisant référence à l'instance (objAccess) est définie sur " Nothing " ou lorsqu'elle perd sa portée.

Propriété Visible

La propriété Visible est en lecture seule ou en lecture-écriture, selon le cas. Elle est en lecture seule lorsque la propriété UserControl est vraie ou lorsque l'instance de Microsoft Access est créée à l'origine par l'utilisateur (et non par le code Automation). Cette propriété est en lecture-écriture lorsque la propriété UserControl est fausse. Toutefois, dans de rares cas, Microsoft Access ne sera pas affiché, même si la propriété Visible est définie sur Vrai, lorsque la propriété Visible de l'instance est déjà vraie et que celle-ci a été réduite par l'utilisateur.

Affichage d'une instance de Microsoft Access

Plusieurs méthodes sont disponibles pour afficher une instance de Microsoft Access avec Automation, selon que Microsoft Access est ouvert ou non lors de l'activation de l'objet Application.

Méthode 1

Lorsque vous créez une nouvelle instance de Microsoft Access à l'aide d'Automation, elle est réduite car la propriété Visible de l'objet Application est définie automatiquement sur Faux. Pour afficher Microsoft Access, vous pouvez définir la propriété Visible sur Vrai. Par exemple :
 Dim objAccess as Object
 Set objAccess = CreateObject("Access.Application")
 objAccess.Visible = True 
Cette méthode fonctionne parce que la fonction CreateObject() ouvre toujours une nouvelle instance de l'application spécifiée. Si vous définissez la propriété Visible immédiatement après avoir exécuté CreateObject(), l'utilisateur ne peut pas intervenir en restaurant ou en réduisant la fenêtre de l'application, ce qui rétablit les propriétés UserControl et Visible.

Toutefois, si vous utilisez la fonction GetObject() au lieu de la fonction CreateObject() et définissez la propriété Visible, votre code risque d'échouer dans les situations suivantes :

  • Si Microsoft Access est déjà en cours lors de l'exécution du code. Dans ce cas, la propriété UserControl est définie sur Vrai, ce qui met la propriété Visible en lecture seule.
  • Si une instance de Microsoft Access est ouverte avec Automation, restaurée par l'utilisateur à l'aide de la barre des tâches, puis réduite par l'utilisateur.
REMARQUE : Pour éviter ces deux limitations, vous pouvez utiliser la méthode 2 pour afficher une instance de Microsoft Access.

Méthode 2

Si vous voulez afficher une instance de Microsoft Access indépendamment de l'intervention de l'utilisateur, vous pouvez utiliser la procédure ShowAccess() décrite ci-dessous. Cette exemple de fonction fait trois appels Windows API pour contrôler une instance de Microsoft Access, indépendamment des paramètres actuels des propriétés UserControl et Visible.
 '---------------------------------------------------------------------- 
 'DÉCLARATIONS
 '---------------------------------------------------------------------- 

 Option Explicit
 Declare Function SetForegroundWindow Lib "User32" _
   (ByVal hWnd As Long) As Long
 Declare Function IsIconic Lib "User32" _
   (ByVal hWnd As Long) As Long
 Declare Function ShowWindow Lib "User32" _
   (ByVal hWnd As Long, ByVal nCmdShow As Long) As Long
 Const SW_NORMAL = 1     'Show window in normal size
 Const SW_MINIMIZE = 2   'Show window minimized
 Const SW_MAXIMIZE = 3   'Show window maximized 
 Const SW_SHOW = 9       'Show window without changing window size

 Dim objAccess As Object 'module-level declaration

 '---------------------------------------------------------------------- '

 ' Cette procédure affiche l'instance de Microsoft Access
 ' " instance ". La taille de la fenêtre de l'instance peut être SW_NORMAL,
 'SW_MINIMIZE, SW_MAXIMIZE, ou SW_SHOW. Si la taille n'est pas précisée, la
 fenêtre reste 
'inchangée (SW_SHOW). Pour appeler cette fonction, utilisez la syntaxe suivante :
 ' ShowAccess instance:=objAccess, size:=SW_SHOW
 '----------------------------------------------------------------------

 Sub ShowAccess(instance As Object, Optional size As Variant)
   Dim hWnd As Long, temp As Long

   If IsMissing(size) Then size = SW_SHOW
   On Error Resume Next
       If Not instance.UserControl Then instance.Visible = True
       On Error GoTo 0 'turn off error handler
       hWnd = instance.hWndAccessApp
       temp = SetForegroundWindow(hWnd)
       If size = SW_SHOW Then 'keep current window size
            If IsIconic(hWnd) Then temp = ShowWindow(hWnd, SW_SHOW)
       Else
            If IsIconic(hWnd) And size = SW_MAXIMIZE Then _
              temp = ShowWindow(hWnd, SW_NORMAL)
            temp = ShowWindow(hWnd, size)
       End If
 End Sub 

Méthode 3

Si vous souhaitez afficher une base de données spécifique en utilisant une instance de Microsoft Access déjà en cours lors de l'exécution de votre code Automation, vous pouvez utiliser la procédure ShowAccess() (décrite ci-dessus dans la méthode 2) avec l'exemple de code suivant :
 '---------------------------------------------------------------------- 
 'Cette procédure ouvre la base de données exemple Comptoir.mdb dans une
 'instance nouvelle ou existante de Microsoft Access (si une instance est déjà
 'ouverte).
 '
 'REMARQUE : Cette procédure utilise la procédure ShowAccess() (décrite ci
  -dessus dans la 'méthode 2). Vous devez entrer cette procédure dans le même
 'module que ShowAccess() pour que le code fonctionne correctement.
 '----------------------------------------------------------------------

 Sub OpenNorthwind()
   Dim path as String

   On Error Resume Next 'temporary error handling
   Set objAccess = GetObject(,"Access.Application")

     If Err <> 0 Then 'no existing instances of Access
       Set objAccess = CreateObject("Access.Application")
     End If

     On Error GoTo OpenNorthwind_ErrHandler 'normal error handler
     ShowAccess instance:=objAccess, size:=SW_MAXIMIZE

     With objAccess
       path = .SysCmd(Access.acSysCmdAccessDir) & "Samples\Comptoir.mdb"
       If .DBEngine.Workspaces(0).Databases.Count = 0 Then 
          .OpenCurrentDatabase filepath:=path
       ElseIf LCase(Right(.CurrentDb.Name, Len("Comptoir.mdb"))) _
           <> "Comptoir.mdb" Then 
          .CloseCurrentDatabase

          .OpenCurrentDatabase filepath:=path
       End If 
       .DoCmd.OpenForm FormName:="Menu général"
     End With
 Exit Sub

 OpenNorthwind_ErrHandler:
   MsgBox Error$(), , "Erreur Ouverture Comptoir"
 End Sub 

Fermeture d'une instance de Microsoft Access

Normalement, une instance de Microsoft Access se ferme automatiquement lorsque la variable objet faisant référence à l'instance est définie sur " Nothing " ou perd sa portée dans l'application du contrôleur. Toutefois, si des objets Microsoft Access sont ouverts dans les affichages suivants, l'instance ne se fermera pas automatiquement comme escompté :
 Objet          Affichage
 ---------------------------------
 Tableau        Feuille de données
 Conception     Requête Feuille de données
 Formulaire     Formulaire
 État           Aperçu avant impression 
Si un objet Microsoft Access est ouvert, l'instance ne se ferme que lorsque les objets sont fermés et que la propriété UserControl de l'objet Application est définie sur Faux. Toutefois, vous pouvez obliger une instance à se fermer en utilisant la méthode Quit d'un objet Application. L'exemple de code suivant utilise la méthode Quit pour fermer toutes les instances de Microsoft Access.
 '---------------------------------------------------------------------- 
 'DÉCLARATIONS 
 '----------------------------------------------------------------------

 Option Explicit

 '---------------------------------------------------------------------- 
 'Cette procédure ferme toutes les instances ouvertes de Microsoft Access. Une
 'fois toutes les instances fermées, le gestionnaire d'erreurs est exécuté et la
 'procédure se termine.
 '----------------------------------------------------------------------

 Sub CloseAllAccess()
   Dim objAccess As Object
   On Error GoTo CloseAllAccess_ErrHandler
     Do
       Set objAccess = GetObject(,"Access.Application")
       objAccess.Quit
     Loop
 CloseAllAccess_ErrHandler:
   Set objAccess = Nothing
 End Sub
AVERTISSEMENT : La méthode Quit ne doit pas être utilisée pour fermer une instance créée par l'appel direct d'une fonction Microsoft Access si votre code fait appel à d'autres fonctions Microsoft Access. Pour plus d'informations sur l'utilisation des fonctions Microsoft Access dans votre code Automation, consultez la section " Appel des fonctions Microsoft Access " ci-dessous.

REMARQUE : Vous pouvez éviter qu'une instance de Microsoft ne se ferme lorsque sa variable objet (objAccess) perd sa portée en déclarant la variable objet publique ou de niveau module plutôt que de niveau procédure.

Par exemple, si la variable objAccess est déclarée au cours d'une procédure, elle n'est utilisable que lors de l'exécution de la procédure. À la fin de la procédure, objAccess perd sa portée et Microsoft Access peut se fermer automatiquement.

Toutefois, si la variable objAccess est déclarée dans la section Déclarations d'un module standard, elle est alors une variable de niveau module, et par conséquent disponible pour toutes les procédures dans ce module. Si objAccess est déclarée comme variable publique dans un module standard, elle est disponible pour toutes les procédures dans la base de données. Dans ces deux cas, objAccess ne perd pas sa portée lorsque votre code Automation est inactif. En conséquence, une connexion à Microsoft Access reste ouverte jusqu'à l'utilisation de la méthode Quit ou la fermeture du contrôleur Automation.

Contournement des paramètres de démarrage lors de l'ouverture d'une base de données

Avec Microsoft Access comme serveur Automation, plusieurs méthodes sont disponibles pour ouvrir une base de données. Vous pouvez par exemple utiliser la fonction GetObject() et spécifier une base de données. Vous pouvez également ouvrir une base de données existante comme base de données courante à l'aide de la méthode OpenCurrentDatabase de l'objet Application.

Si une base de données possède des paramètres de démarrage personnalisés ou une macro AutoExec, ces fonctionnalités sont exécutées lorsque vous utilisez une méthode OpenCurrentDatabase. Toutefois, vous pouvez utiliser une instruction SendKeys pour simuler l'action d'appuyer sur la touche MAJ lors de l'ouverture de la base de données, ce qui permet de contourner les paramètres de démarrage et la macro AutoExec. Vous pouvez utiliser l'exemple de code :
 Dim objAccess as object
 Set objAccess = CreateObject("Access.Application")

    ShowAccess instance:=objAccess, size:=SW_MAXIMIZE
    SendKeys "+"
    'Simulates holding down the SHIFT key as the database is being opened
    objAccess.OpenCurrentDatabase filepath:= _
       "C:\Program Files\Microsoft Office\Office\Samples\Comptoir.mdb" 
Pour que l'instruction SendKeys fonctionne correctement, votre code doit répondre aux conditions suivantes :

  • Le code doit utiliser la liaison tardive, c'est-à-dire que la variable faisant référence à une instance de Microsoft Access est déclarée comme objet, comme par exemple dans :
     Dim objAccess as Object
     Set objAccess = CreateObject("Access.Application") 
    Vous ne pouvez pas utiliser la liaison anticipée, qui déclare la variable comme utilisant un type d'objet défini par l'application, comme par exemple dans :
     Dim objAccess as Access.Application
     Set objAccess = CreateObject("Access.Application ") 
  • Le code permet d'assurer que Microsoft Access est visible et que le pointeur de la souris se situe dans la fenêtre Microsoft Access. Si Microsoft Access n'est pas la fenêtre active, exécutez une procédure telle que la fonction ShowAccess()(décrite plus haut dans la section " Affichage d'une instance de Microsoft Access ").
  • La propriété AllowBypassKey de la base de données contrôlée à l'aide d'Automation est définie sur Vrai (par défaut).
  • La méthode OpenCurrentDatabase apparaît immédiatement après l'instruction SendKeys et ne contient aucune calcul. Par exemple, au lieu d'utiliser le code suivant :
     objAccess.OpenCurrentDatabase filepath:= _
     objAccess.SysCmd(Access.acSysCmdAccessDir) &"Samples\Comptoir.mdb"
     SendKeys "
     +" 
    utilisez l'exemple de code :
     path = objAccess.SysCmd(Access.acSysCmdAccessDir) & _
       "Samples\Comptoir.mdb"
     SendKeys "+"
     objAccess.OpenCurrentDatabase filepath:=path 

Appel de fonctions Microsoft Access

Dans votre code Automation, vous pouvez appeler des fonctions intégrées Microsoft Access telles que Eval(), Syscmd() ou Dlookup(), tant que la procédure est exposée à l'objet Application. Pour vérifier si une fonction est disponible, procédez comme suit :

  1. Ouvrez un module.
  2. Dans le menu Outils, cliquez sur Références.
  3. Dans la zone Références, sélectionnez Bibliothèque d'objets Microsoft Access 8.0 (ou Microsoft Access pour Windows 95 dans la version 7.0), puis cliquez sur OK.
  4. Dans le menu Affichage, cliquez sur Explorateur d'objets.
  5. Dans la zone Explorateur d'objets, sous Bibliothèques/Bases de données, sélectionnez " Access " (ou " Access - Microsoft Access pour Windows 95 " dans la version 7.0).
  6. Sous Classes (ou Modules/Classes dans la version 7.0), cliquez sur Application. Remarquez que les fonctions listées pour l'objet Application s'affichent dans la zone Membres (ou la zone Méthodes/Propriétés dans la version 7.0). Vous pouvez les utiliser dans votre code Automation.
Lorsque vous utilisez une fonction Microsoft Access dans un code Automation, vous pouvez appeler la fonction directement, en utilisant l'objet Application, ou indirectement, en utilisant une variable objet définie sur une instance de Microsoft Access. Ces deux méthodes sont détaillées ci-dessous.

Appel direct d'une fonction Microsoft Access

Pour appeler une fonction Microsoft Access directement, vous devez disposer d'une référence à la Bibliothèque d'objets Microsoft Access 8.0 (ou Microsoft Access pour Windows 95 dans la version 7.0) dans votre contrôleur Automation. Pour plus d'informations sur la création d'une référence, consultez la section " Création d'une référence à Microsoft Access " de cet article.

Une fois la référence à Microsoft Access établie, vous pouvez utiliser l'objet Application " Access " pour appeler une fonction Microsoft Access, comme par exemple :
 MsgBox Access.Eval("2+2") 'displays "4"
 MsgBox Access.SysCmd(Access.acSysCmdAccessDir) 'displays the path 
Lors du premier appel direct d'une fonction Microsoft Access par un contrôleur Automation, une nouvelle instance réduite de Microsoft Access est créée. Le contrôleur maintient une connexion à cette instance au cas où votre code ferait d'autres appels à des fonctions Microsoft Access, et cette connexion reste active jusqu'à la fermeture de l'application du contrôleur.

REMARQUE : Il n'est pas recommandé d'utiliser la méthode Quit d'un objet Application pour fermer une instance créée par l'appel direct d'une fonction Microsoft Access. Ceci peut provoquer une erreur Automation dans votre contrôleur si vous appelez une autre fonction Microsoft Access ultérieurement. Pour éviter tout risque d'erreur, vous pouvez laisser le contrôleur fermer l'instance réduite automatiquement lors de la fermeture du contrôleur.

Appel indirect d'une fonction Microsoft Access

Pour appeler une fonction Microsoft Access indirectement, il n'est pas nécessaire de créer une référence à la bibliothèque d'objets (contrairement à l'appel direct). Dans votre code Automation, vous pouvez utiliser une variable objet définie sur une instance de Microsoft Access pour appeler une fonction Microsoft Access, comme par exemple :
 Dim objAccess as Object
 On Error Resume Next
   Set objAccess = GetObject(,"Access.Application")
     If Err <> 0 Then 'no instance of Access is open
       Set objAccess = CreateObject("Access.Application")
     End If
     MsgBox objAccess.Eval("2+2") 'displays 4
     MsgBox objAccess.SysCmd(Access.acSysCmdAccessDir) 'displays the path 

Appel de procédures personnalisées

Dans votre code Automation, vous pouvez appeler une procédure Visual Basic personnalisée stockée dans une base de données Microsoft Access à l'aide de la méthode Exécuter de l'objet Application. La procédure personnalisée doit être déclarée comme publique et se trouver dans un module standard (pas un module de formulaire ou d'état). Par exemple, vous pouvez ajouter la fonction suivante à un nouveau module dans la base de données exemple Comptoir.mdb :
 Public Function MyDateAdd(interval As String, number As Integer, _
   startdate As Date) As Date
   MyDateAdd = DateAdd(interval, number, startdate)
     'Calls the Microsoft Access built-in DateAdd function.
 End Function 
Pour exécuter la fonction ci-dessus, ajoutez le code suivant à votre contrôleur Automation :
 Dim objAccess as Object, newdate as Date
 Set objAccess = GetObject _
    ("C:\Program Files\Microsoft Office\Office\Samples\Comptoir.mdb")
 newdate = objAccess.Run("MyDateAdd", "m", 1, Date)
 MsgBox newdate,,"Retour de la fonction MyDateAdd " 

Utilisation d'une application exécutable

Si vous voulez contrôler une application exécutable Microsoft Access à l'aide d'Automation, vous devrez peut-être effectuer plusieurs modifications de code, particulièrement si la version de Microsoft Access installée sur l'ordinateur de l'utilisateur n'est pas la version commerciale complète :

  • Comme une version exécutable de Microsoft Access ne peut pas démarrer sans base de données, vous devez tout d'abord vérifier si une instance est déjà en cours. Si ce n'est pas le cas, ouvrez la version exécutable à l'aide de la fonction Shell() et spécifiez un chemin d'accès à Msaccess.exe et une base de données.
  • Après avoir démarré une instance exécutable de Microsoft Access à l'aide de votre code, utilisez GetObject() pour faire référence à cette instance.
  • Assurez-vous que votre code n'affiche pas une instance exécutable avant d'ouvrir une base de données. Sinon, l'instance sera brièvement affichée à l'écran, puis réduite.
  • Pour fermer une instance exécutable de Microsoft Access, utilisez la méthode Quit de l'objet Application, comme par exemple :
     objAccess.Quit 
Pour ouvrir une instance exécutable de Microsoft Access, vous pouvez utiliser la procédure suivante :
 '---------------------------------------------------------------------- 
 'DÉCLARATIONS 
 '----------------------------------------------------------------------

 Option Explicit
 Dim objAccess as Object

 '----------------------------------------------------------------------
 'Cette procédure définit une variable de niveau module, objAccess, comme
 'faisant référence à une instance de Microsoft Access. Le code tente tout
 'd'abord d'utiliser GetObject() pour faire référence à une instance peut-être
 'déjà ouverte contenant la base de données spécifiée (dbpath). Si la base de
 'données n'est pas déjà ouverte dans une instance de Microsoft Access, une
 'nouvelle instance de la version complète de 'Microsoft Access est ouverte. Si
 'la version complète de Microsoft Access n'est pas installée, la fonction
 'Shell() démarre une instance exécutable de Microsoft Access. Une fois
 'l'instance ouverte, vous pouvez utiliser les méthodes 
 'CloseCurrentDatabase et OpenCurrentDatabase pour travailler avec d'autres
 'bases de données.
 '----------------------------------------------------------------------

 Sub OpenRunTime()
   Dim accpath As String, dbpath As String
   On Error Resume Next
   dbpath = "C:\My Application\MyApp.mdb"
   Set objAccess = GetObject(dbpath)
   If Err <> 0 Then
     If Dir(dbpath) = "" Then 'dbpath is not valid
       MsgBox "Couldn't find database."
       Exit Sub
   Else    'The full version of Microsoft Access is not installed.
     accpath = "C:\Program Files\Common Files\Microsoft Shared" & _
          "\Microsoft Access Runtime\MSAccess.exe"
     If Dir(accpath) = "" Then
        MsgBox "Couldn't find Microsoft Access."
        Exit Sub
     Else
        Shell pathname:=accpath & " " & Chr(34) & dbpath & Chr(34), _
          windowstyle:=6
        Do 'Wait for shelled process to finish
          Err = 0
          Set objAccess = GetObject(dbpath)
        Loop While Err <> 0
     End If
   End If
 End If
 End Sub 

Utilisation d'un groupe de travail sécurisé

Si l'application Microsoft Access que vous voulez contrôler utilise un groupe de travail sécurisé (System.mdv), vous voudrez peut-être contourner la boîte d'ouverture de session qui requiert un nom d'utilisateur et un mot de passe. L'exemple de code suivant utilise la fonction Shell()pour démarrer Microsoft Access et passer un nom d'utilisateur et un mot de passe à l'application :
 '----------------------------------------------------------------------
 'DÉCLARATIONS 
 '----------------------------------------------------------------------

 Option Explicit Dim objAccess as Object

 '----------------------------------------------------------------------
 'Cette procédure définit une variable de niveau module, objAccess, comme
 'faisant référence à une instance de Microsoft Access. Le code tente tout
 'd'abord d'utiliser GetObject pour faire référence à une instance peut-être
 'déjà ouverte. Si aucune instance n'est 'ouverte, la fonction Shell() ouvre une
 'nouvelle instance et 'spécifie le nom d'utilisateur et le mot de passe, en se
 'basant sur les arguments passés à la procédure.
 '
 'Exemple d'appel : OpenSecured varUser:="Admin", varPw:=""
 '----------------------------------------------------------------------

 Sub OpenSecured(Optional varUser As Variant, Optional varPw As Variant)
    Dim cmd As String
    On Error Resume Next
    Set objAccess = GetObject(, "Access.Application")
    If Err <> 0 Then 'no instance of Access is open
      If IsMissing(varUser) Then varUser = "Admin"
      cmd = "C:\Program Files\Microsoft Office\Office\MSAccess.exe"
      cmd = cmd & " /nostartup /user " & varUser
      If Not IsMissing(varPw) Then cmd = cmd & " /pwd " & varPw
      Shell pathname:=cmd, windowstyle:=6
      Do 'Wait for shelled process to finish.
        Err = 0
        Set objAccess = GetObject(, "Access.Application")
      Loop While Err <> 0
    End If
 End Sub 

Exemples

Cette section contient deux exemples de procédures pour le contrôle d'une fonctionnalité Microsoft Access à partir d'un contrôleur Automation tel que Microsoft Excel, Microsoft Project ou Microsoft Visual Basic. Les deux procédures accomplissent les tâches suivantes : aperçu ou impression d'un état ; appel d'un Assistant État pour la création d'un nouvel état.

REMARQUE : Ces procédures requièrent une référence à la bibliothèque d'objets Microsoft Access dans l'application du contrôleur Automation. Pour plus d'informations sur la création d'une référence, consultez la section " Création d'une référence à Microsoft Access " de cet article.

Aperçu ou impression d'un état

Vous pouvez utiliser la procédure suivante pour imprimer ou afficher un aperçu d'un état dans Microsoft Access à partir d'un contrôleur Automation :
 '----------------------------------------------------------------------
 'DÉCLARATIONS
 '----------------------------------------------------------------------

 Option Explicit

 '----------------------------------------------------------------------
 'Cette procédure imprime ou affiche l'aperçu d'un état, puis ferme 
 'l'instance en cours de Microsoft Access (parce que objAccess est une 
 'variable de niveau procédure). Pour appeler cette procédure, utilisez
 'la syntaxe suivante :
 '   PrintAccessReport _
 '   dbname:= _
 '     "C:\Program Files\Microsoft Office\Office\Samples\Comptoir.mdb",
 '     rptname:="Ventes par catégorie", preview:=True
 '----------------------------------------------------------------------
 Sub PrintAccessReport(dbname As String, rptname As String, _
   preview As Boolean)
   Dim objAccess As Object
   On Error GoTo PrintAccessReport_ErrHandler
   Set objAccess = CreateObject("Access.Application")
   With objAccess
     .OpenCurrentDatabase filepath:=dbname
     If preview Then 'Preview report on screen.
       .Visible = True
       .DoCmd.OpenReport reportname:=rptname, _
          view:=Access.acPreview
     Else 'Print report to printer.
       .DoCmd.OpenReport reportname:=rptname, _
          view:=Access.acNormal
        DoEvents 'Allow report to be sent to printer.
     End If
   End With
   Set objAccess = Nothing
   Exit Sub

 PrintAccessReport_ErrHandler:
   MsgBox Error$(), , "Erreur d'impression Access"
 End Sub 

Appel d'un Assistant État pour la création d'un nouvel état

Vous pouvez utiliser la procédure suivante pour démarrer l'Assistant État dans Microsoft Access à partir d'un contrôleur Automation :
 '----------------------------------------------------------------------
 'DÉCLARATIONS
 '----------------------------------------------------------------------

 Option Explicit
 Dim objAccess as Object

 '----------------------------------------------------------------------

 'Cette procédure démarre l'Assistant État dans Microsoft Access en utilisant
 'une base de données et une table (ou requête) spécifiés comme source
 'd'enregistrement. Cette 'procédure ne ferme pas l'instance de Microsoft
 'Access car objAccess est une variable de niveau module. Pour appeler cette
 'procédure, utilisez la syntaxe suivante :
 '   CallReportWizard _
 '     dbname:= _
 '     "C:\Program Files\Microsoft Office\Office\Samples\Comptoir.mdb",
 '      sourcetype:="table", sourcename:="Employés"
 '----------------------------------------------------------------------

 Sub CallReportWizard(dbname As String, sourcetype As String, _
   sourcename As String)
   Dim objtype As Integer
   On Error GoTo CallReportWizard_ErrHandler
   Set objAccess = CreateObject("Access.Application")
   With objAccess
     .Visible = True
     .OpenCurrentDatabase filepath:=dbname
     If LCase(sourcetype) = "table" Then
       objtype = Access.acTable
     Else objtype = Access.acQuery
     End If
     .DoCmd.SelectObject objecttype:=objtype, _
        objectname:=sourcename, inDatabaseWindow:=True

     'Quoique la ligne de code suivante fonctionne dans Microsoft Access 97,
     'DoMenuItem n'existe que pour raisons de compatibilité amont. Dans
     'Microsoft Access 97, utilisez plutôt la méthode RunCommand suivante :
     '.DoCmd.RunCommand (acCmdNewObjectReport)
      .DoCmd.DoMenuItem MenuBar:=1, MenuName:=3, Command:=3, _
         Version:=Access.acMenuVer70
         'Database menubar, Insert menu, Report command
    End With
    Exit Sub

 CallReportWizard_ErrHandler:
   If Err <> 2501 Then 'Error did not occur by canceling Report Wizard.
     MsgBox Error$(), , "Erreur lors de l'appel de l'Assistant État"
   End If
 End Sub 

Références

Pour plus d'informations sur l'utilisation de Microsoft Access comme serveur Automation, effectuez une recherche, basée sur le mot " Automation " à partir de l'onglet Index de l'aide, ou formulez votre question au Compagnon Office de Microsoft Access 97.

Propriétés

Numéro d'article: 147816 - Dernière mise à jour: jeudi 15 janvier 2004 - Version: 3.0
Les informations contenues dans cet article s'appliquent au(x) produit(s) suivant(s):
  • Microsoft Access 95 Standard
  • Microsoft Access 97 Standard
Mots-clés : 
inf: intpolea kbofficeprog kbole KB147816
L'INFORMATION CONTENUE DANS CE DOCUMENT EST FOURNIE PAR MICROSOFT SANS GARANTIE D'AUCUNE SORTE, EXPLICITE OU IMPLICITE. L'UTILISATEUR ASSUME LE RISQUE DE L'UTILISATION DU CONTENU DE CE DOCUMENT. CE DOCUMENT NE PEUT ETRE REVENDU OU CEDE EN ECHANGE D'UN QUELCONQUE PROFIT.
Exclusion de responsabilité concernant les contenus obsolètes dans la Base de connaissances
Cet article concerne des produits pour lesquels Microsoft n'offre plus de support. Il est par conséquent fourni « en l'état » et ne sera plus mis à jour.

Envoyer des commentaires

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com