Qu'est-ce qu'une DLL ?

Traductions disponibles Traductions disponibles
Numéro d'article: 815065 - Voir les produits auxquels s'applique cet article
Agrandir tout | Réduire tout

Sommaire

Résumé

Cet article explique ce qu'est une bibliothèque de liaisons dynamiques (DLL) et les différents problèmes que vous pouvez rencontrer lorsque vous utilisez des DLL.

Ensuite, il explique quelques problèmes avancés que vous devez prendre en compte lorsque vous développez vos propres DLL. Pour décrire une DLL, cet article explique des méthodes de liaison dynamique, les dépendances des DLL, les points d'entrée de DLL, l'exportation des fonctions de DLL et les outils de dépannage de DLL.

Cet article se termine par une comparaison approfondie entre les DLL et les assemblys Microsoft .NET Framework.

INTRODUCTION

Bon nombre des fonctionnalités des systèmes d'exploitation Microsoft Windows répertoriés dans la liste des produits concernés par cet article sont fournies par les bibliothèques de liaisons dynamiques (DLL). En outre, lorsque vous exécutez un programme sous l'un de ces systèmes d'exploitation Windows, une grande partie des fonctionnalités du programme peut être fournie par les DLL. Par exemple, certains programmes peuvent contenir beaucoup de modules différents, chaque module du programme est alors contenu et distribué dans les DLL.

L'utilisation des DLL contribue à favoriser la modularisation de code, la réutilisation de code, une utilisation efficace de la mémoire et la réduction de l'espace disque utilisé. Par conséquent, le système d'exploitation et les programmes se chargent et s'exécutent plus rapidement et ils occupent moins d'espace disque sur l'ordinateur.

Lorsqu'un programme utilise une DLL, un problème appelé la dépendance peut empêcher l'exécution du programme. Lorsqu'un programme utilise une DLL, une dépendance est créée. Si un autre programme remplace et rompt cette dépendance, le programme d'origine ne peut pas fonctionner correctement.

Avec la publication de Microsoft .NET Framework, la plupart des problèmes de dépendance ont été éliminés grâce à des assemblys.

Plus d'informations

Qu'est-ce qu'une DLL ?

Une DLL est une bibliothèque contenant du code et des données qui peuvent être utilisés en même temps par plusieurs programmes. Par exemple, la DLL Comdlg32 assure les fonctions communes liées aux boîtes de dialogue dans les systèmes d'exploitation Windows. Chaque programme peut ainsi utiliser les fonctionnalités contenues dans cette DLL pour implémenter une boîte de dialogue Ouvrir. Cela permet de favoriser la réutilisation de code et d'optimiser l'utilisation de la mémoire.

En utilisant une DLL, un programme peut être modularisé en composants distincts. Par exemple, un programme de comptabilité peut être vendu par module. Chaque module peut être chargé dans le programme principal au moment de l'exécution, s'il est installé. Dans la mesure où les modules sont séparés, le temps de chargement du programme est plus rapide, et un module est chargé uniquement lorsque ses fonctionnalités sont nécessaires.

En outre, les mises à jour sont plus faciles à appliquer à chaque module, sans que cela n'affecte les autres parties du programme. Par exemple, vous pouvez posséder un programme de gestion des salaires, les taux d'imposition changent chaque année. Lorsque ces modifications sont isolées dans une DLL, vous pouvez appliquer une mise à jour sans devoir générer ou installer de nouveau l'ensemble du programme.

La liste suivante décrit quelques-uns des fichiers implémentés comme DLL dans les systèmes d'exploitation Windows :
  • Fichiers de contrôles ActiveX (.ocx)
    Un contrôle ActiveX est, par exemple, un contrôle Calendrier qui vous permet de sélectionner une date dans un calendrier.
  • Fichiers du panneau de configuration (.cpl)
    Un fichier .cpl peut être un élément qui se trouve dans le Panneau de configuration. Chaque élément est une DLL spécialisée.
  • Fichiers de pilote de périphérique (.drv)
    Un pilote de périphérique est par exemple un pilote d'imprimante qui contrôle l'impression vers une imprimante.

Avantages des DLL

La liste suivante décrit quelques-uns des avantages offerts lorsqu'un programme utilise une DLL :
  • Le programme utilise moins de ressources
    Lorsque plusieurs programmes utilisent la même bibliothèque de fonctions, une DLL peut réduire la duplication du code qui est chargé sur le disque et dans la mémoire physique. Cela peut influencer grandement la performance non seulement du programme fonctionnant au premier plan, mais également des autres programmes qui s'exécutent sur le système d'exploitation Windows.
  • Une DLL favorise une architecture modulaire
    Une DLL favorise le développement de programmes modulaires. Cela vous permet de développer des programmes volumineux, qui requièrent plusieurs versions linguistiques, ou un programme qui nécessite une architecture modulaire. Un exemple d'un programme modulaire est un programme de comptabilité comprenant de nombreux modules qui peuvent être chargés dynamiquement au moment de l'exécution.
  • Une DLL facilite le déploiement et l'installation
    Lorsqu'une fonction dans une DLL a besoin d'une mise à jour ou d'un correctif, le déploiement et l'installation de la DLL ne nécessitent pas la recréation du lien entre le programme et la DLL. En outre, si plusieurs programmes utilisent la même DLL, ces programmes bénéficieront tous de la mise à jour ou du correctif. Ce problème peut se produire plus fréquemment lorsque vous utilisez une DLL d'un fournisseur tiers qui est mise à jour ou corrigée régulièrement.

Dépendances de DLL

Lorsqu'un programme ou une DLL utilise une fonction DLL dans une autre DLL, une dépendance est créée. Par conséquent, le programme n'est plus indépendant et il peut rencontrer des problèmes si la dépendance est rompue. Par exemple, le programme ne peut pas s'exécuter dans l'une des situations suivantes :
  • Une DLL dépendante est mise à niveau vers une nouvelle version.
  • Une DLL dépendante est corrigée.
  • Une DLL dépendante est remplacée par une version antérieure.
  • Une DLL dépendante est supprimée de l'ordinateur.
Ces situations sont en général appelées conflits de DLL. Si la compatibilité en amont n'est pas assurée, le programme peut ne pas s'exécuter correctement.

La liste suivante décrit les modifications qui ont été introduites dans Microsoft Windows 2000 et les systèmes d'exploitation Windows ultérieurs pour réduire les problèmes de dépendance :
  • Protection de fichier Windows
    Dans la Protection de fichier Windows, le système d'exploitation empêche la mise à jour ou la suppression des DLL système par un agent non autorisé. Ainsi, lorsqu'une installation de programme essaie de supprimer ou de mettre à jour une DLL qui est définie comme DLL système, la Protection de fichier Windows recherchera une signature numérique valide.
  • DLL privées
    Les DLL privées vous permettent d'isoler un programme des modifications qui sont apportées aux DLL partagées. Les DLL privées utilisent des informations spécifiques à la version ou un fichier .local vide pour appliquer la version de la DLL utilisée par le programme. Pour utiliser des DLL privées, localisez vos DLL dans le dossier racine des programmes. Ensuite, pour les nouveaux programmes, ajoutez à la DLL des informations spécifiques à la version. Pour les programmes anciens, utilisez un fichier .local vide. Chaque méthode ordonne au système d'exploitation d'utiliser les DLL privées situées dans le dossier racine de programmes.

Outils de dépannage de DLL

Plusieurs outils sont disponibles pour résoudre les problèmes de DLL. Voici quelques-uns de ces outils.

Dependency Walker

L'outil Dependency Walker peut rechercher itérativement toutes les DLL dépendantes utilisées par un programme. Lorsque vous ouvrez un programme dans Dependency Walker, il exécute les contrôles suivants :
  • Dependency Walker recherche les DLL manquantes.
  • Il recherche les fichiers programmes ou les DLL qui ne sont pas valides.
  • Il vérifie que les fonctions d'importation et les fonctions d'exportation correspondent.
  • Il recherche les erreurs de dépendance circulaire.
  • Il recherche les modules qui ne sont pas valides car ils appartiennent à un autre système d'exploitation.
Grâce à Dependency Walker, vous pouvez documenter toutes les DLL utilisées par un programme. Cela peut permettre d'empêcher et de corriger les problèmes de DLL qui peuvent se produire dans le futur. Dependency Walker se trouve dans le répertoire suivant lorsque vous installez Microsoft Visual Studio 6.0 :
lecteur\Program Files\Microsoft Visual Studio\Common\Tools

DLL Universal Problem Solver

L'outil DLL Universal Problem Solver (DUPS) permet de vérifier, de comparer, de documenter et d'afficher les informations des DLL. La liste suivante décrit les utilitaires contenus dans l'outil DUPS :
  • Dlister.exe
    Cet utilitaire énumère toutes les DLL sur l'ordinateur et enregistre ces informations dans un fichier texte ou un fichier de base de données.
  • Dcomp.exe
    Cet utilitaire compare les DLL répertoriées dans deux fichiers texte et génère un troisième fichier texte indiquant les différences.
  • Dtxt2DB.exe
    Cet utilitaire charge les fichiers texte qui sont créés avec les utilitaires Dlister.exe et Dcomp.exe dans la base de données dllHell.
  • DlgDtxt2DB.exe
    Cet utilitaire fournit une version GUI (interface utilisateur graphique) de l'utilitaire Dtxt2DB.exe.
Pour plus d'informations sur l'outil DUPS, cliquez sur le numéro ci-dessous pour afficher l'article correspondant dans la Base de connaissances Microsoft.
247957 Utilisation de DUPS.exe pour résoudre les problèmes de compatibilité des DLL

Base de données d'aide sur les DLL

La base de données d'aide sur les DLL vous aide à localiser des versions spécifiques de DLL qui sont installées par les logiciels Microsoft. Pour plus d'informations sur la base de données d'aide sur les DLL, visitez le site Web de Microsoft à l'adresse suivante :
http://support.microsoft.com/dllhelp/

Développement de DLL

Cette section décrit les problèmes et les configurations requises à prendre en compte lorsque vous développez vos propres DLL.

Types de DLL

Lorsque vous chargez une DLL dans une application, deux méthodes de liaison vous permettent d'appeler les fonctions de DLL exportées. Ces deux méthodes de liaison sont la liaison dynamique au moment du chargement et la liaison dynamique au moment de l'exécution.
Liaison dynamique au moment du chargement
Dans la liaison dynamique au moment du chargement, une application émet des appels explicites aux fonctions DLL exportées, telles que les fonctions locales. Pour utiliser la liaison dynamique au moment du chargement, fournissez un fichier d'en-tête (.h) et un fichier de bibliothèque d'importation (.lib) lorsque vous compilez et liez l'application. Lors de cette opération, l'éditeur de liens fournit au système les informations requises pour charger la DLL et définir les emplacements de fonction DLL exportée au moment du chargement.
Liaison dynamique au moment de l'exécution
Dans la liaison dynamique au moment de l'exécution, une application appelle la fonction LoadLibrary ou LoadLibraryEx pour charger la DLL au moment de l'exécution. Une fois la DLL chargée avec succès, vous utilisez la fonction GetProcAddress pour obtenir l'adresse de la fonction DLL exportée que vous souhaitez appeler. Lorsque vous utilisez la liaison dynamique au moment de l'exécution, vous n'avez pas besoin d'un fichier bibliothèque d'importation.

La liste suivante décrit les critères d'application pour savoir quand utiliser la liaison dynamique au moment du chargement et quand utiliser la liaison dynamique au moment de l'exécution :
  • Performances au démarrage
    Si les performances au démarrage initial de l'application sont importantes, vous devez utiliser la liaison dynamique au moment de l'exécution.
  • Facilité d'utilisation
    Dans la liaison dynamique au moment du chargement, les fonctions DLL exportées sont similaires aux fonctions locales. Il est ainsi facile pour vous d'appeler ces fonctions.
  • Logique d'application
    Dans la liaison dynamique au moment de l'exécution, une application peut choisir de charger tels ou tels modules, selon les besoins. Ceci est important lorsque vous développez des versions multilingues.

Le point d'entrée de DLL

Lorsque vous créez une DLL, vous pouvez facultativement spécifier une fonction de point d'entrée. La fonction de point d'entrée est appelée lorsque des processus ou des threads s'attachent à la DLL ou se détachent de la DLL. Vous pouvez utiliser la fonction de point d'entrée pour initialiser des structures de données ou en détruire, selon les besoins de la DLL. En outre, si l'application est multithread, vous pouvez utiliser le stockage local des threads (TLS) dans la fonction de point d'entrée pour allouer la mémoire privée à chaque thread. Le code suivant est un exemple de fonction de point d'entrée de DLL.
BOOL APIENTRY DllMain(
HANDLE hModule,	// Handle to DLL module
	DWORD ul_reason_for_call,	// Reason for calling function
	LPVOID lpReserved ) // Reserved
{
	switch ( ul_reason_for_call )
	{
		case DLL_PROCESS_ATTACHED:
		// A process is loading the DLL.
		break;
		case DLL_THREAD_ATTACHED:
		// A process is creating a new thread.
		break;
		case DLL_THREAD_DETACH:
		// A thread exits normally.
		break;
		case DLL_PROCESS_DETACH:
		// A process unloads the DLL.
		break;
	}
	return TRUE;
}
Lorsque la fonction de point d'entrée renvoie une valeur FALSE, l'application ne démarrera pas si vous utilisez la liaison dynamique au moment du chargement. Si vous utilisez la liaison dynamique au moment de l'exécution, seule la DLL individuelle ne se chargera pas.

La fonction de point d'entrée doit uniquement effectuer les tâches d'initialisation simples et ne doit pas appeler une autre fonction de chargement ou d'arrêt de DLL. Par exemple, dans la fonction de point d'entrée, vous ne devez ni directement ni indirectement appeler la fonction LoadLibrary ou la fonction LoadLibraryEx. En outre, vous ne devez pas appeler la fonction FreeLibrary lorsque le processus se termine.

Remarque Dans les applications multithread, assurez-vous que cet accès aux données communes de DLL est synchronisé (thread-safe) pour éviter l'endommagement possible des données. Pour ce faire, utilisez TLS pour fournir des données uniques pour chaque thread.

Exportation de fonctions DLL

Pour exporter des fonctions DLL, vous pouvez ajouter un mot clé de fonction aux fonctions DLL exportées ou créer un fichier de définition de module (.def) répertoriant les fonctions DLL exportées.

Pour utiliser un mot clé de fonction, vous devez déclarer chaque fonction à exporter avec le mot clé suivant :
__declspec(dllexport)
Pour utiliser des fonctions DLL exportées dans l'application, vous devez déclarer chaque fonction à importer avec le mot clé suivant :
__declspec(dllimport)
En général, vous utilisez un fichier d'en-tête avec une instruction define et une instruction ifdef pour séparer l'instruction d'exportation et l'instruction d'importation.

Vous pouvez également utiliser un fichier de définition de module pour déclarer des fonctions DLL exportées. Lorsque vous utilisez un tel fichier, vous ne devez pas ajouter de mot clé de fonction aux fonctions DLL exportées. Dans le fichier de définition de module, vous déclarez l'instruction LIBRARY et l'instruction EXPORTS pour la DLL. Le code suivant constitue un exemple du fichier de définition :
// SampleDLL.def
//
LIBRARY "sampleDLL"

EXPORTS
  HelloWorld

Exemple de DLL et application

Dans Microsoft Visual C++ 6.0, vous pouvez créer une DLL en sélectionnant le type de projet Win32 Dynamic-Link Library (Bibliothèque de liens dynamiques Win32) ou MFC AppWizard (dll).

Le code suivant est un exemple d'une DLL qui a été créée dans Visual C++ en utilisant le type de projet Bibliothèque de liens dynamiques Win32.
// SampleDLL.cpp
//

#include "stdafx.h"
#define EXPORTING_DLL
#include "sampleDLL.h"

BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
{
    return TRUE;
}

void HelloWorld()
{
	MessageBox( NULL, TEXT("Hello World"), TEXT("In a DLL"), MB_OK);
}
// File: SampleDLL.h
//
#ifndef INDLL_H
#define INDLL_H

#ifdef EXPORTING_DLL
extern __declspec(dllexport) void HelloWorld() ;
#else
extern __declspec(dllimport) void HelloWorld() ;
#endif

#endif
Le code suivant est un exemple d'un projet Application Win32 qui appelle la fonction DLL exportée dans la DLL SampleDLL.
// SampleApp.cpp 
//

#include "stdafx.h"
#include "sampleDLL.h"

int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{ 		HelloWorld();
	return 0;
}
Remarque Dans la liaison dynamique au moment du chargement, vous devez lier la bibliothèque d'importation SampleDLL.lib qui est créée lors de la génération du projet SampleDLL.

Dans la liaison dynamique au moment de l'exécution, vous utilisez un code semblable au suivant pour appeler la fonction DLL exportée de SampleDLL.dll.
...
typedef VOID (*DLLPROC) (LPTSTR);
...
HINSTANCE hinstDLL;
DLLPROC HelloWorld;
BOOL fFreeDLL;

hinstDLL = LoadLibrary("sampleDLL.dll");
if (hinstDLL != NULL)
{
    HelloWorld = (DLLPROC) GetProcAddress(hinstDLL, "HelloWorld");
    if (HelloWorld != NULL)
        (HelloWorld);

    fFreeDLL = FreeLibrary(hinstDLL);
}
...
Lorsque vous compilez et liez l'application SampleDLL, le système d'exploitation Windows recherche la DLL SampleDLL dans les emplacements suivants et dans cet ordre :
  1. Le dossier d'application
  2. Le dossier actif
  3. Le dossier System de Windows

    Remarque La fonction GetSystemDirectory retourne le chemin d'accès du dossier System de Windows.
  4. Le dossier Windows

    Remarque La fonction GetWindowsDirectory renvoie le chemin d'accès du dossier Windows.

L'assembly .NET Framework

Avec l'introduction de Microsoft .NET et de .NET Framework, la plupart des problèmes associés aux DLL ont été éliminés en utilisant des assemblys. Un assembly est une unité logique de fonctionnalités qui s'exécutent sous le contrôle du Common Language Runtime .NET (CLR). Un assembly existe physiquement en tant que fichier .DLL ou en tant que fichier .exe. Toutefois, un assembly est intrinsèquement très différent d'une DLL Microsoft Win32.

Un fichier d'assembly contient un manifeste de l'assembly, des métadonnées de type, un code Microsoft Intermediate Language (MSIL) et d'autres ressources. Le manifeste de l'assembly contient les métadonnées de l'assembly fournissant toutes les informations nécessaires pour qu'un assembly soit autodescriptif. Les informations suivantes sont incluses dans le manifeste de l'assembly :
  • Nom de l'assembly
  • Informations de version
  • Informations de culture
  • Informations sur les noms forts
  • La liste d'assemblys de fichiers
  • Des informations de référence de type
  • Des informations sur les assemblys dépendants et référencés
Le code MSIL contenu dans l'assembly ne peut pas être exécuté directement. Son exécution est gérée par le biais du CLR. Par défaut, lorsque vous créez un assembly, il est privé à l'application. Créer un assembly partagé nécessite l'affectation d'un nom fort à l'assembly puis la publication de l'assembly dans le Cache de l'assembly global.

La liste suivante compare quelques-unes des fonctionnalités d'assemblys par rapport aux fonctionnalités des DLL Win32 :
  • Autodescriptif
    Lorsque vous créez un assembly, toutes les informations requises par le CLR pour l'exécuter sont contenues dans le manifeste de l'assembly. Ce manifeste contient une liste des assemblys dépendants. Ainsi, le CLR peut maintenir la cohérence des assemblys utilisés dans l'application. Dans les DLL Win32, vous ne pouvez pas maintenir de cohérence dans un ensemble de DLL utilisées dans une application lorsque vous utilisez des DLL partagées.
  • Détermination de version
    Dans un manifeste d'assembly, les informations de version sont enregistrées et sont appliquées par le CLR. Les stratégies de version vous permettent en outre de mettre en vigueur une utilisation spécifique à la version. Dans les DLL Win32, le suivi des versions ne peut pas être mis en oeuvre par le système d'exploitation. Au contraire, vous devez vous assurer que les DLL sont compatibles en amont.
  • Déploiement côte à côte
    Les assemblys prennent en charge le déploiement côte à côte. Une application peut utiliser une version d'un assembly et une autre application une version différente du même assembly. Apparu dans Windows 2000, le déploiement côte à côte est pris en charge en plaçant des DLL dans le dossier d'application. En outre, la Protection de fichiers Windows empêche le remplacement des DLL système par un agent non autorisé.
  • Autonomie et isolation
    Une application qui est développée en utilisant un assembly peut être autonome et isolée des autres applications qui s'exécutent sur l'ordinateur. Cette fonctionnalité vous aide à créer des installations à impact nul.
  • Exécution
    Un assembly est exécuté sous les autorisations de sécurité fournies dans le manifeste de l'assembly et qui sont contrôlées par le CLR.
  • Indépendance par rapport au langage
    Un assembly peut être développé en utilisant n'importe lequel des langages pris en charge par .NET. Par exemple, vous pouvez développer un assembly dans Microsoft Visual C#, puis utiliser cet assembly dans un projet Microsoft Visual Basic .NET.

Références

Pour plus d'informations sur les DLL et les assemblys .NET Framework, visitez les sites Web de Microsoft aux adresses suivantes :
Base de données d'aide sur les DLL
http://support.microsoft.com/dllhelp

Conflits de DLL (en anglais)
http://msdn2.microsoft.com/en-us/library/ms811694.aspx

Implémentation côte à côte du partage de composants dans les applications (en anglais)
http://msdn2.microsoft.com/en-us/library/ms811700.aspx

Comment faire pour générer et maintenir des applications isolées et des assemblys côte à côte pour Windows XP (en anglais)
http://msdn2.microsoft.com/en-us/library/ms997620.aspx

Simplification du déploiement et de la résolution des conflits de DLL avec .NET Framework (en anglais)
http://msdn.microsoft.com/library/en-us/dndotnet/html/dplywithnet.asp

Le guide du développeur .NET Framework : Assemblys (en anglais)
http://msdn.microsoft.com/library/en-us/cpguide/html/cpconassemblies.asp

Liaison dynamique au moment de l'exécution (en anglais)
http://msdn2.microsoft.com/en-us/library/ms685090.aspx

Stockage local des threads (en anglais)
http://msdn2.microsoft.com/en-us/library/ms686749.aspx

Propriétés

Numéro d'article: 815065 - Dernière mise à jour: mardi 4 décembre 2007 - Version: 5.5
Les informations contenues dans cet article s'appliquent au(x) produit(s) suivant(s):
  • Microsoft Windows Server 2003, Datacenter Edition (32-bit x86)
  • Microsoft Windows Server 2003, Datacenter Edition for Itanium-Based Systems
  • Microsoft Windows Server 2003, Datacenter x64 Edition
  • Microsoft Windows Server 2003, Enterprise Edition (32-bit x86)
  • Microsoft Windows Server 2003, Enterprise Edition for Itanium-based Systems
  • Microsoft Windows Server 2003, Enterprise x64 Edition
  • Microsoft Windows Server 2003, Standard Edition (32-bit x86)
  • Microsoft Windows Server 2003, Standard x64 Edition
  • Microsoft Windows Server 2003, Web Edition
  • Microsoft Windows 2000 Advanced Server
  • Microsoft Windows 2000 Datacenter Server
  • Microsoft Windows 2000 Server
  • Microsoft Windows XP Professional
  • Microsoft Windows XP Édition familiale
  • Microsoft Windows XP Media Center Edition
  • Microsoft Windows XP Tablet PC Edition
  • Microsoft Windows 2000 Professionnel
  • Microsoft Windows NT 4.0
  • Microsoft Windows NT Workstation 4.0 Édition Développeur
  • Microsoft Windows NT Workstation 3.51
  • Microsoft Windows 98 Deuxième Édition
  • Microsoft Visual Studio .NET 2003 Professional
  • Microsoft Visual Studio .NET 2003 Enterprise Architect
  • Microsoft Visual Studio .NET 2003 Enterprise Developer
  • Microsoft Visual Studio .NET 2003 Éducation
  • Microsoft Visual Studio .NET 2002 Professional Edition
  • Microsoft Visual Studio .NET 2002 Enterprise Architect
  • Microsoft Visual Studio .NET 2002 Enterprise Developer
  • Microsoft Visual Studio .NET 2002 Éducation
  • Microsoft Visual Studio 6.0 Professional Edition
  • Microsoft Visual Studio 6.0 Enterprise Edition
  • Microsoft Visual Studio 2005 Express Edition
  • Microsoft Visual Studio 2005 Professional Edition
  • Microsoft Visual Studio 2005 Standard Edition
  • Microsoft Office XP Professional
  • Microsoft Office XP Édition PME
  • Microsoft Office XP Standard
  • Microsoft Office Édition Standard 2003
  • Microsoft Office Édition Professionnelle 2003
  • Microsoft Office Édition PME 2003
  • Microsoft Office Édition Standard 2003
Mots-clés : 
kbxplatform kbtshoot kbdebug kbdll kbinfo KB815065
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.

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