Afin de faciliter le travail de leurs collègues et de fournir à tous les programmes Windows une interface universelle, les programmeurs Microsoft ont créé une API - "Application Programming Interface".

Il s'agit d'un ensemble de fonctions et de procédures qui peuvent être le plus souvent utilisées par les programmes : afficher une arborescence de répertoires, rechercher des fichiers, afficher une fenêtre standard avec des boutons de fermeture, de réduction et d'agrandissement, et bien d'autres. En conséquence, un développeur créant un programme pour Windows n'a pas besoin de réfléchir et de développer des sous-programmes spéciaux pour afficher la fenêtre du programme, la fenêtre de sélection d'un dossier et d'autres opérations élémentaires similaires - il peut simplement appeler kernel32.dll ou user32.dll des bibliothèques contenant des fonctions et des procédures API, la fonction dont il a besoin, et elle fera tout elle-même pour lui. Il existe de nombreuses fonctions et procédures de ce type - environ 600.

En salle d'opération Système MS-DOS il n'y avait pas d'API - celui qui a entrepris d'écrire un programme pour cela système opérateur, a été obligé de réfléchir et de mettre en œuvre, de bout en bout, des méthodes permettant d'afficher une image à l'écran, de recevoir des données de l'utilisateur, de parcourir le système de fichiers, de dessiner des graphiques, si une telle possibilité était nécessaire 2 . Cela a fait du processus de développement de programmes avec une interface conviviale un processus très laborieux ; souvent le temps et les efforts consacrés à la création d'une interface graphique acceptable pour le programme dépassaient les coûts de mise en œuvre du propre algorithme du programme, pour lequel il a été créé. . Ce n’est pas pour rien que les applications dites « consoles », c’est-à-dire les programmes qui fonctionnent uniquement depuis ligne de commande, sans interface - les données ont été saisies sur la même ligne de commande ou créées à partir d'un fichier qui y est spécifié, et les résultats ont été affichés en mode texte simple.

Avec l'avènement de la salle d'opération Systèmes Windows Le travail éreintant des programmeurs pour développer l'apparence du programme et des moyens pratiques de saisie et de sortie d'informations a été grandement facilité - les fonctions API étaient déjà utilisées dans Windows 3.0. Désormais programmeur, si, par exemple, il voulait créer une fenêtre de saisie de texte ou une barre de défilement, il lui suffisait d'écrire un appel à la fonction permettant d'afficher une telle fenêtre avec les paramètres dont il avait besoin, comme n'importe quelle autre fonction du langage dans lequel il a écrit son programme, et de ne pas introduire d'énormes quantités de code pour créer un programme qui redessine une telle fenêtre ou barre (tout en étant conscient que lors du développement du prochain programme utilisant également de tels objets, il devra développer refaire ce code ou essayer d'utiliser partiellement l'ancien, en l'adaptant aux besoins de ce nouveau programme). Par conséquent, l'émergence de l'API a constitué une percée révolutionnaire dans la technologie de programmation, vous permettant de créer beaucoup plus rapidement les programmes nécessaires avec une interface familière et pratique, sans vous soucier de détails de routine tels que la programmation d'objets d'interface standard pour l'entrée et la sortie d'informations.

Dans le langage Visual Basic pour Applications (VBA), de nombreuses fonctions et procédures API sont appelées elles-mêmes lorsque le programme est exécuté par l'interpréteur, il n'est donc absolument pas nécessaire de les utiliser pour afficher des fenêtres de saisie et de sortie de texte, dessiner des formes géométriques sur le écran et autres actions simples - VBA les appelle selon les besoins et le programme qui s'y trouve n'a besoin que d'utiliser les fonctions appropriées de ce langage. Cependant, certaines actions sont parfois nécessaires pour lesquelles soit il n'y a pas d'analogues dans les fonctions VBA intégrées, soit elles fonctionnent de manière irrationnelle ou trop lente. Par exemple, une fenêtre de sélection de dossier avec une image d'une arborescence de répertoires (Fig. 5.1) ou un programme de recherche de fichiers (analogue dans les fonctions VBA - l'objet "Application.FileSearch" - fonctionne trop lentement avec un grand nombre de fichiers). Dans de tels cas, VBA offre la possibilité d'appeler des fonctions API.

Malheureusement, l'utilisation des fonctions API dans VBA n'est pas documentée dans l'aide, donc pour apprendre à les utiliser, vous devez soit rechercher des livres ou des sources en ligne sur la programmation bureautique, soit analyser le code des programmes contenant des appels aux fonctions API.

Dans la grande majorité des cas, lors de la programmation pour Office, vous pouvez vous passer de l'API, mais parfois le simple appel d'une fonction API peut obtenir résultat désiré. Disons que vous devez vous assurer que différentes macros sont appelées lorsque vous cliquez simplement sur un bouton d'un panneau avec la souris. Outils Word et dans le cas d'un appui simultané sur ce bouton et sur la touche Shift ou Control. Voici un extrait de code faisant ceci :

Déclarer la fonction GetAsyncKeyState Lib "user32.dll" (ByVal kState As Long) sous forme d'entier

GetAsyncKeyState (vbKeyShift ou vbKeyControl)

Si GetAsyncKeyState(vbKeyShift) Alors

Appeler la macro1 : Quitter le sous-marin

ElseIf GetAsyncKeyState(vbKeyControl) Alors

Appeler la macro2 : Quitter le sous-marin

La première ligne revient à « réserver » une fonction API pour une utilisation dans un programme VBA. On voit que la fonction GetAsyncKeyState est appelée depuis la bibliothèque (un fichier contenant des programmes destinés uniquement à être utilisés par d'autres programmes) user32.dll, et le numéro de clé est passé à cette fonction, et elle renvoie un entier (à savoir 0, si la touche avec le numéro correspondant n'est pas enfoncée, et -32767 ou 1 si enfoncée). Toute fonction ou procédure appelée à partir de bibliothèques non VBA doit être ainsi réservée à l'aide de la commande Declare.

La phrase vbKeyShift dans la commande remplace le code de la touche Shift (sa valeur est 16) et vbKeyControl, comme il est facile à comprendre, remplace le code de la touche Control. La structure des instructions "If...Then" semble claire 3, mais sinon, consultez l'aide de VBA. La commande Appeler avant le nom de la macro, comme vous vous en souvenez, signifie la lancer.

Il existe des sites russes sur Internet dédiés à l'API 4. Visitez-les pour en savoir plus sur cet ensemble de fonctionnalités.

API Windows - un ensemble de fonctions du système d'exploitation

L'abréviation API semble très mystérieuse et même effrayante pour de nombreux programmeurs débutants. En fait, une interface de programmation d'application (API) n'est qu'un ensemble de fonctions prêtes à l'emploi que les développeurs d'applications peuvent utiliser. En général, ce concept équivaut à ce qu’on appelait auparavant plus souvent une bibliothèque de sous-programmes. Cependant, API fait généralement référence à une catégorie spéciale de ces bibliothèques.

Lors du développement de presque toutes les applications assez complexes (MyApplication) pour l'utilisateur final, un ensemble de fonctions internes spécifiques est formé qui sont utilisées pour implémenter ce programme particulier, appelé API MyApplication. Cependant, il s'avère souvent que ces fonctions peuvent être utilisées efficacement pour créer d'autres applications, y compris par d'autres programmeurs. Dans ce cas, les auteurs, en fonction de la stratégie de promotion de leur produit, doivent trancher la question : ouvrent-ils ou non l'accès à cet ensemble aux utilisateurs externes ? Si la réponse est oui, la phrase « Le package comprend un ensemble ouvert de fonctions API » apparaît dans la description du progiciel comme une caractéristique positive (mais parfois pour de l'argent supplémentaire).

Ainsi, le plus souvent, une API fait référence à un ensemble de fonctions qui font partie d'une application, mais qui sont également disponibles pour être utilisées dans d'autres programmes. Par exemple, Excel, en plus de l'interface utilisateur final, dispose d'un ensemble Fonctions Excel Une API qui peut être utilisée notamment lors de la création d'applications utilisant VB.

En conséquence, l'API Windows est un ensemble de fonctions qui font partie du système d'exploitation lui-même et sont en même temps accessibles à toute autre application, y compris celles écrites en VB. À cet égard, l'analogie avec le jeu d'interruptions système BIOS/DOS, qui est en fait une API DOS, est tout à fait justifiée.

La différence est que la gamme de fonctions de l'API Windows, d'une part, est beaucoup plus large que celle du DOS et, d'autre part, elle n'inclut pas de nombreux outils de gestion directe des ressources informatiques qui étaient disponibles pour les programmeurs dans le passé. Système d'exploitation. De plus, les appels à l'API Windows sont effectués à l'aide d'appels de procédure ordinaires et les appels aux fonctions DOS sont effectués via une instruction spéciale du processeur appelée Interruption.

Pourquoi avons-nous besoin de l’API Win pour les programmeurs VB ?

Malgré le fait que VB dispose d'une grande variété de fonctions, au cours d'un développement plus ou moins sérieux, on découvre que leurs capacités ne sont souvent pas suffisantes pour résoudre les problèmes nécessaires. Dans le même temps, les programmeurs débutants commencent souvent à se plaindre des défauts de VB et à penser à changer d'outils, sans se douter que leur ordinateur dispose d'un vaste ensemble d'outils et qu'ils ont juste besoin de savoir comment les utiliser.

Lors d'une réunion Gagner l'API Il s'avère que de nombreuses fonctions VB intégrées ne sont rien de plus que des appels aux procédures système correspondantes, mais uniquement implémentées sous la forme de la syntaxe d'un langage donné. Compte tenu de cela, la nécessité d'utiliser l'API est déterminée par les options suivantes :

1. Fonctions API entièrement implémentées en tant que fonctions VB intégrées. Néanmoins, parfois dans ce cas, il est utile de passer à l'utilisation de l'API, car cela peut parfois améliorer considérablement les performances (notamment en raison de l'absence de transformations inutiles des paramètres transmis).
2. Les fonctions VB intégrées n'implémentent qu'un cas particulier de la fonction API correspondante. C'est joli option régulière. Par exemple, la fonction API CreateDirectory a plus de fonctionnalités que l'opérateur VB MkDir intégré.
3. Un grand nombre de fonctions API n'ont aucun analogue dans la version actuelle du langage VB. Par exemple, vous ne pouvez pas supprimer un répertoire à l'aide de VB - pour ce faire, vous devez utiliser la fonction SupprimerDirectory.

Il convient également de souligner que certaines fonctions de l'API (leur part dans l'API Win est très faible) ne peuvent pas être appelées à partir de programmes VB en raison d'un certain nombre de limitations du langage, par exemple en raison de l'impossibilité de travailler avec des adresses mémoire. Mais dans certains cas, des techniques de programmation non triviales peuvent aider (notamment dans le cas des mêmes adresses).

Le point de vue personnel de l'auteur est qu'au lieu d'étendre les fonctions intégrées de version en version, VB aurait dû être donné bonne description les fonctions API les plus populaires. En même temps, je conseille aux développeurs de ne pas attendre l'apparition nouvelle version des outils dotés de fonctions avancées et examinez de plus près la composition de l'API Win existante - il est probable que les capacités dont vous avez besoin auraient déjà pu être implémentées dans la version VB 1.0, publiée en 1991.

Comment apprendre l'API Win

Ce n'est pas une question si simple, étant donné que le nombre de fonctions de l'API Win32 est estimé à environ 10 000 (personne ne connaît le chiffre exact, pas même Microsoft).

VB (versions 4-6) inclut un fichier décrivant les déclarations de l'API Win - WIN32API.TXT (nous vous en dirons plus sur son utilisation plus tard). Mais, d'une part, avec son aide, vous pouvez obtenir des informations sur le but d'une fonction particulière et ses paramètres uniquement par les noms mnémoniques utilisés, et d'autre part, la liste des fonctions de ce fichier est loin d'être complète. À une certaine époque (il y a sept ans), VB 3.0 disposait de fichiers d'aide spéciaux décrivant les fonctions de l'API Win16. Cependant, déjà dans la version 4.0, ces informations utiles avec une interface pratique ont disparu.

Des informations complètes sur l'API Win32 sont disponibles dans l'aide du kit de développement logiciel de plate-forme, incluse dans les CD MSDN Library fournis avec VB 5.0 et 6.0 Enterprise Edition et Office 2000 Developer Edition. Cependant, y trouver les informations nécessaires et les comprendre n'est pas du tout facile. Sans compter que toutes les descriptions qui y sont données sont données en relation avec le langage C.

Les livres du célèbre expert américain Daniel Appleman sont généralement reconnus dans le monde pour l'apprentissage de la programmation API dans l'environnement VB. Sa série Guide du programmeur Visual Basic de Dan Appleman pour les fenêtres L'API (pour Win16, Win32, en relation avec différentes versions de VB) depuis 1993 figure régulièrement parmi les best-sellers des programmeurs VB. Le livre VB 5.0 Programmer's Guide to the Win32 API de Dan Appleman, publié en 1997, a été apporté à l'auteur des États-Unis par un ami qui l'a trouvé dans la première librairie d'une petite ville de province.

Ce livre fait plus de 1 500 pages, couvrant les techniques générales de programmation d'API en VB, ainsi que plus de 900 fonctions. Le CD qui l'accompagne contient le texte intégral du livre et tous exemples de programmes, ainsi que plusieurs chapitres supplémentaires qui n'étaient pas inclus dans la version imprimée. En 1999, Dan Appleman a publié un nouveau livre, Dan Appleman's Win32 API Puzzle Book and Tutorial for Visual Basic Programmers, qui comprend des informations sur 7 600 autres fonctions (mais pas aussi complètes).

API Win et bibliothèque de liens dynamiques (DLL)

L'ensemble de l'API Win est implémenté sous forme de DLL dynamiques. Ensuite, nous parlerons en fait de la technologie d'utilisation des DLL dans l'environnement VB en utilisant l'exemple des bibliothèques incluses dans l'API Win. Cependant, lorsqu’on parle de DLL, il y a quelques points importants à souligner.

Dans ce cas, par DLL, nous entendons la version traditionnelle des bibliothèques dynamiques binaires, qui fournissent aux applications un accès direct aux procédures nécessaires - sous-programmes ou fonctions (de la même manière que ce qui se passe lors de l'appel de procédures dans un projet VB). De telles bibliothèques peuvent être créées en utilisant différents instruments: VC++, Delphi, Fortran, sauf VB (voyons ce qui apparaît dans la version 7.0) - ce dernier ne peut faire que des DLL ActiveX, accessibles via l'interface OLE Automation.

Généralement, les fichiers de bibliothèque dynamiques portent l'extension .DLL, mais cela n'est pas du tout nécessaire (pour Win16, l'extension .EXE était souvent utilisée) ; les pilotes de périphériques externes sont désignés à l'aide de .DRV.

Comme nous l'avons déjà noté, il est assez difficile de déterminer le nombre exact de fonctions de l'API Windows et les fichiers qui les contiennent, mais elles se trouvent toutes dans le répertoire système. À cet égard, il est préférable de souligner la composition des bibliothèques incluses dans le noyau du système d'exploitation et les principales bibliothèques dotées de fonctions supplémentaires clés.

Et maintenant quelques conseils.

Astuce 1. Assurez-vous que votre annonce DL est correctement formatée Procédures L

L'appel même aux procédures DLL dans un programme ressemble exactement à celui des procédures Visual Basic « normales », par exemple :

Appeler DllName ([liste d'arguments])

Cependant, pour utiliser des fonctions DLL externes (y compris Win API), elles doivent être déclarées dans le programme à l'aide de l'instruction Declare, qui ressemble à ceci :

Déclarez Sub ProcedureName Lib _ « LibraryName » _ [([ArgumentList])]

Déclarer la fonction FunctionName _ Lib « LibraryName » _ [([ArgumentList])]

Ici, les éléments facultatifs de l'opérateur sont affichés entre crochets, les expressions variables sont en italique et les mots restants sont des mots clés. Le système d'aide donne une assez bonne description de la syntaxe de l'opérateur, nous ne noterons donc pour l'instant que quelques points.

Les déclarations de fonctions externes doivent être placées dans la section Déclarations générales du module. Si vous le placez dans un module de formulaire, alors vous devez spécifier le mot-clé Private (cette déclaration ne sera disponible qu'à l'intérieur de ce module) - il s'agit d'une limitation pour toutes les procédures du module de formulaire.

L'ensemble de l'API Win32 est implémenté uniquement sous forme de fonctions (l'API Win16 avait de nombreuses sous-routines). Ce sont principalement des fonctions Type long, qui renvoie le plus souvent le code de fin de l'opération.

L'opérateur Declare est apparu dans MS Basic à l'époque du DOS et il était également utilisé pour déclarer les procédures internes du projet. Dans Visual Basic, cela n'est pas obligatoire, puisque la déclaration des procédures internes est automatiquement leur déclaration Sub ou Function. Par rapport à Basic/DOS, la nouvelle description doit indiquer le nom du fichier bibliothèque où se trouve la procédure requise. Les bibliothèques de l'API Wip se trouvent dans le répertoire système Windows, il suffit donc de fournir uniquement le nom du fichier. Si vous accédez à une DLL située à un emplacement arbitraire, vous devez écrire chemin completà ce fichier.

La description de l'instruction Declare prend généralement beaucoup de place et ne tient pas sur une seule ligne dans la fenêtre de code. Par conséquent, nous vous recommandons de respecter un schéma de saut de ligne spécifique lors de l'écriture d'applications, par exemple :

Déclarer la fonction GetTempPath _ Lib « kernel32 » Alias ​​​​« GetTempPathA » _ (ByVal nBufferLength As Long, _ ByVal lpBuffer As String) As Long

Dans ce cas, tous les éléments principaux de la description sont placés sur des lignes différentes et sont donc faciles à lire.

Astuce 2 : Soyez particulièrement prudent lorsque vous travaillez avec des fonctions DLL

L'utilisation de l'API Win et de diverses fonctions DLL étend considérablement les fonctionnalités de VB et améliore souvent les performances du programme. Cependant, le prix à payer est le risque de réduire la fiabilité de l’application, notamment lors de son débogage.

L'un des avantages les plus importants de l'environnement VB est la fiabilité du processus de développement du programme : fonctionnant sous le contrôle d'un interprète, code de programme ne peut théoriquement pas perturber le fonctionnement de Windows et de VB lui-même. Le programmeur peut ne pas faire très attention à l'exactitude de la transmission des paramètres aux fonctions appelées - de telles erreurs seront facilement détectées par l'interpréteur lui-même soit pendant le processus de traduction du code, soit lors de son exécution. Dans le cas le plus désagréable, le mode de traitement sera simplement interrompu, avec une indication de l'endroit et de la raison pour laquelle l'erreur s'est produite.

L'utilisation de fonctions API Windows ou d'autres DLL supprime directement ce contrôle sur le transfert de données et le processus d'exécution de code en dehors de l'environnement VB. Par conséquent, une erreur d'accès aux fonctions externes peut entraîner l'inopérabilité de VB et du système d'exploitation. Cela est particulièrement vrai au stade du développement du programme, lorsque la présence d'erreurs est tout à fait naturelle. Ainsi, en utilisant les capacités plus larges des fonctions de la couche de base du système, le programmeur assume la responsabilité de leur utilisation correcte.

Le problème est encore aggravé par le fait que différents langages de programmation utilisent différentes manières de transmettre les paramètres entre les procédures. (Plus précisément, différentes méthodes de transmission sont utilisées par défaut, car de nombreux langages peuvent prendre en charge plusieurs méthodes.) Les API Win sont implémentées en C/C++ et utilisent des conventions de transmission de paramètres C/C++ qui diffèrent de la version VB habituelle.

A cet égard, il convient de noter que l'apparition d'analogues de fonctions API intégrées à VB se justifie précisément par l'adaptation de ces dernières à la syntaxe VB et la mise en œuvre d'un mécanisme de contrôle des échanges de données approprié. Notons également qu'au stade du débogage expérimental de l'application lors de la création d'un module exécutable, il est préférable d'utiliser l'option de compilation P-code au lieu du Native Code (code machine). Dans le premier cas, le programme s'exécutera sous le contrôle d'un interprète - plus lent que le code machine, mais plus fiable du point de vue d'un éventuel impact erroné sur le système d'exploitation et offrant un mode plus pratique pour identifier d'éventuelles erreurs.

Astuce 3 : les dix conseils de Dan Appleman pour une programmation API robuste en VB

L'utilisation de la fonction API nécessite une programmation plus minutieuse utilisant des techniques d'appel de procédure moins familières (par rapport à VB). Nous continuerons à aborder ces questions dans ce qui suit. Et maintenant, nous présentons un résumé des conseils formulés par Dan Appleman sur ce sujet (leur première version est parue en 1993) avec certains de nos ajouts et commentaires.

1. N'oubliez pas ByVal. L'erreur la plus courante commise lors de l'accès aux fonctions API et DLL est l'utilisation incorrecte du mot-clé ByVal : soit ils oublient de le mettre, soit, à l'inverse, le mettent lorsqu'il n'est pas nécessaire.

Ces exemples montrent l'impact de l'opérateur ByVal sur le passage des paramètres

Type de paramètre	Avec ByVal	Sans ByVal
Entier	Un entier de 16 bits est poussé sur la pile	L'adresse 32 bits d'un entier 16 bits est poussée sur la pile
Long	Un entier de 32 bits est placé sur la pile	L'adresse 32 bits d'un entier 32 bits est poussée sur la pile
Chaîne	La chaîne est convertie au format utilisé en C (données et octet nul de fin). L'adresse 32 bits de la nouvelle ligne est poussée sur la pile	Le handle VB de la chaîne est poussé sur la pile. (Ces handles ne sont jamais utilisés par l'API Windows elle-même et ne sont reconnus que dans les DLL implémentées spécifiquement pour VB.)

Il convient de rappeler ici que passer des paramètres à n'importe quel système de programmation, y compris VB, est exécuté de deux manières principales : par référence (ByRef) ou par valeur (ByVal). Dans le premier cas, l'adresse de la variable est transmise (cette option est utilisée par défaut en VB), dans le second - sa valeur. La différence fondamentale est qu'en utilisant une référence, la valeur modifiée du paramètre passé est renvoyée au programme appelant.

Pour comprendre cela, réalisez une expérience en utilisant les programmes suivants :

Dim v Comme entier v = 2 Appeler MyProc(v) MsgBox « v = » & v Sub MyProc (v Comme entier) v = v + 1 End Sub

Lorsque vous exécutez cet exemple, vous recevrez un message avec valeur variable, égal à 3. Le fait est que dans ce cas l'adresse de la variable v, créée physiquement dans le programme appelant, est transmise au sous-programme MyProc. Modifiez maintenant la description de la procédure en

Sub MyProc (ByVal contre Entier)

En conséquence, lors de l'exécution du test, vous obtiendrez v = 2, car seule la valeur initiale de la variable est transmise à la procédure - le résultat des opérations effectuées sur celle-ci n'est pas renvoyé au programme appelant. Le mode de transfert par valeur peut également être modifié à l'aide de l'opérateur d'appel comme suit :

Sub MyProc (v As Integer) ... Call MyProc((v)) ‘ (v) - les parenthèses indiquent le mode de transfert par valeur.

Cependant, lors de l'accès aux procédures VB internes, l'utilisation du mot clé ByVal dans l'instruction Call est interdite - des parenthèses sont utilisées à la place. Il y a une explication à cela.

Dans le cas classique (C, Fortran, Pascal), la différence entre les modes ByRef et ByVal dépend de ce qui est exactement placé sur la pile d'échange de données - l'adresse de la variable ou sa valeur. Basic utilise historiquement une variante de l'émulation logicielle ByVal - il y a toujours une adresse sur la pile, mais uniquement lors du passage par valeur, une variable temporaire est créée à cet effet. Pour distinguer ces deux options (Classic et Basic), différentes manières de décrire le mode ByVal sont utilisées. A noter qu'émuler le mode ByVal en VB offre une plus grande fiabilité du programme : en mélangeant la forme de référence, le programmeur risque seulement que la valeur corrigée de la variable soit renvoyée (ou non) au programme appelant. Dans la version « classique », une telle confusion peut conduire à une erreur fatale lors de l'exécution d'une procédure (par exemple, lorsqu'une valeur de variable égale, par exemple, à zéro, est utilisée à la place d'une adresse mémoire).

Les fonctions DLL sont implémentées selon des principes « classiques » et nécessitent donc une description obligatoire de la manière dont les données sont échangées avec chacun des arguments. Les déclarations de fonctions via la description Declare (plus précisément, la liste des arguments passés) servent cet objectif. Le moyen le plus courant de transmettre des paramètres à une fonction API Windows ou à une DLL consiste à utiliser le mot clé ByVal. De plus, il peut être spécifié à la fois dans l'opérateur Declare et directement lors de l'appel de la fonction.

Les conséquences d’un passage incorrect de paramètres sont faciles à prévoir. Si vous recevez une adresse manifestement invalide, vous recevrez un message GPF (General Protection Fault). Si la fonction reçoit une valeur qui correspond à une adresse valide, alors la fonction API entrera dans une zone étrangère (par exemple, le noyau Windows) avec toutes les conséquences désastreuses qui en découleront.

2. Vérifiez le type de paramètres transmis. Le nombre et le type corrects de paramètres transmis sont tout aussi importants. Il faut que les arguments déclarés dans Declare correspondent aux paramètres attendus dans la fonction API. Le cas d'erreur le plus courant lors du passage de paramètres concerne la différence entre NULL et une chaîne de longueur nulle - rappelez-vous que ce n'est pas la même chose.

3. Vérifiez le type de retour.

VB est assez tolérant aux incompatibilités de types de retour fonction des valeurs, puisque les valeurs numériques sont généralement renvoyées via des registres plutôt que via la pile. Les règles suivantes aideront à déterminer valeur correcte, renvoyé par la fonction API :

• Une fonction DLL qui ne renvoie pas de valeur (analogue à void en 'C') doit être déclarée comme VB Sub.
• Une fonction API qui renvoie une valeur entière (Integer ou Long) peut être définie comme un Sub ou une Function qui renvoie une valeur du type approprié.
• Aucune des fonctions API ne renvoie des nombres à virgule flottante, mais certaines DLL peuvent très bien renvoyer ce type de données.

4. Utilisez la construction « As Any » avec beaucoup de soin. De nombreuses fonctions de l'API Windows ont la capacité d'accepter des paramètres divers types et utilisez la construction As Any (l'interprétation du type est effectuée en fonction de la valeur des autres paramètres transmis).

Une bonne solution dans ce cas peut être d'utiliser plusieurs alias (Alias) d'une fonction en créant deux ou plusieurs déclarations pour la même fonction, chaque déclaration spécifiant des paramètres d'un type spécifique.

5. N'oubliez pas d'initialiser les chaînes. Il existe de nombreuses fonctions dans l'API Win qui renvoient des informations en chargeant des données dans des tampons de chaîne passés en paramètre. Dans votre programme, vous pouvez apparemment tout faire correctement : n'oubliez pas ByVal, transmettez correctement les paramètres à la fonction. Mais Windows ne peut pas vérifier la taille de la mémoire allouée à une ligne. La taille de la ligne doit être suffisamment grande pour accueillir toutes les données qui peuvent y être placées. Responsabilité de la réservation du tampon la bonne taille incombe au programmeur VB.

Il convient de noter que dans Windows 32 bits, lors de l'utilisation de chaînes, la conversion est effectuée d'Unicode (codage sur deux octets) vers ANSI (codage sur un octet) et inversement, en tenant compte des paramètres du système national. Par conséquent, pour réserver des tampons, il est parfois plus pratique d'utiliser des tableaux d'octets plutôt que des variables de chaîne. (Plus d'informations à ce sujet ci-dessous.)

Le plus souvent, les fonctions Win API permettent de définir vous-même la taille maximale des blocs. En particulier, cela nécessite parfois d’appeler une autre fonction API qui « indiquera » la taille du bloc. Par exemple, GetWindowTextLength vous permet de déterminer la longueur de la chaîne nécessaire pour contenir le titre de la fenêtre renvoyé par la fonction GetWindowText. Dans ce cas, Windows veille à ce que vous n'exagériez pas.

6. Assurez-vous d'utiliser Option Explicit.

7. Vérifiez soigneusement les valeurs des paramètres et les valeurs de retour. VB a bonnes opportunités sur la vérification de type. Cela signifie que lorsque vous essayez de transmettre un paramètre invalide à une fonction VB, le pire qui puisse arriver est que vous receviez un message d'erreur de VB. Mais ce mécanisme ne fonctionne malheureusement pas lors de l'accès Fonctions Windows API.

Windows 9x a amélioré la vérification des paramètres pour la plupart des fonctions API. Par conséquent, la présence d’une erreur dans les données ne provoque généralement pas d’erreur fatale, mais il n’est pas si facile d’en déterminer la cause.

Ici, nous vous recommandons d'utiliser plusieurs méthodes pour déboguer ce type d'erreur :

• utiliser mode pas à pas débogage ou la commande Debug.Print pour vérifier chaque appel de fonction API suspect. Vérifiez les résultats de ces appels pour vous assurer que tout est normal et que la fonction s'est correctement exécutée ;
• utilisez un débogueur Windows comme CodeView et un débogueur Version Windows(disponible dans le SDK Windows). Ces outils peuvent détecter une erreur de paramètre et au moins déterminer quelle fonction API est à l'origine de l'erreur ;
• Utilisez des outils tiers supplémentaires pour vérifier les types de paramètres et la validité de leurs valeurs. De tels outils peuvent non seulement trouver les erreurs de paramètres, mais même pointer vers la ligne de code VB où l'erreur s'est produite.

De plus, il est nécessaire de vérifier le résultat de l'exécution de la fonction API.

8. N'oubliez pas que les entiers en VB et sous Windows ne sont pas la même chose. Tout d’abord, vous devez garder à l’esprit que le terme « Integer » en VB signifie un nombre de 16 bits, alors que dans la documentation Win 32, cela signifie un nombre de 32 bits. Deuxièmement, les nombres entiers (Integer et Long) en VB sont des quantités signées (c'est-à-dire qu'un chiffre est utilisé comme signe, le reste comme mantisse du nombre), sous Windows, seuls les nombres non négatifs sont utilisés. Cette circonstance doit être gardée à l'esprit lorsque vous formez le paramètre passé en utilisant opérations arithmétiques(par exemple, calculez l'adresse en additionnant une base et un décalage). Les fonctions arithmétiques VB standard ne conviennent pas pour cela. Nous discuterons séparément de ce qu'il faut faire dans ce cas.

9. Portez une attention particulière aux noms de fonctions. Contrairement à Win16, les noms de toutes les fonctions de l'API Win32 sont sensibles à l'utilisation exacte des lettres minuscules et majuscules (ce n'était pas le cas dans Win16). Si vous utilisez quelque part une lettre minuscule au lieu d'une lettre majuscule ou vice versa, la fonction souhaitée ne sera pas trouvée. Veillez également à utiliser correctement le suffixe A ou W dans les fonctions utilisant des paramètres de chaîne. (Pour en savoir plus, voir ci-dessous.)

10. Enregistrez souvent votre travail. Erreurs liées à un invalide en utilisant la DLL et Win API, peut entraîner un arrêt d'urgence de l'environnement VB, et éventuellement de l'ensemble du système d'exploitation. Vous devez vous assurer que le code que vous écrivez est enregistré avant l’exécution du test. Le plus simple est de paramétrer le mode d'enregistrement automatique des modules du projet avant de démarrer le projet dans l'environnement VB.

Après avoir lu les conseils précédents, vous pensez peut-être qu’utiliser les fonctions de l’API Win est risqué. Dans une certaine mesure, cela est vrai, mais seulement en comparaison avec la programmation sécurisée fournie par VB lui-même. Mais avec une utilisation habile et une connaissance des pièges possibles, ce risque est minime. De plus, il est souvent tout simplement impossible d'abandonner complètement l'utilisation de l'API Win - elles seront toujours nécessaires pour tout développement sérieux.

De plus, nous avons mentionné précédemment les pièges d’une large classe de DLL. Dans le cas de l'API Win, tout est beaucoup plus simple, puisque le formulaire d'accès à ces fonctions est clairement unifié. Il convient de garder à l’esprit les principaux points suivants :

1. Les fonctions de l'API Win32 ne sont que cela : des fonctions, c'est-à-dire des procédures de type Function (il y avait de nombreuses sous-routines dans l'API Win16). Ce sont toutes des fonctions de type Long, leurs descriptions sont donc écrites sous la forme suivante : Déclarer Nom de la fonction ... As Long 'le type de fonction _ est défini explicitement

   Déclarer le nom de la fonction& ' le type de fonction _ est déterminé à l'aide du suffixe

   L'appel à la fonction API ressemble à ceci :

Résultat& = NomApi& ([ Liste d'arguments]

1. Le plus souvent, la valeur de retour d'une fonction est le code de fin de l'opération. De plus, une valeur non nulle dans ce cas signifie un achèvement normal, zéro signifie une erreur. Habituellement (mais pas toujours), vous pouvez clarifier la nature de l'erreur en appelant la fonction GetLastError. La description de cette fonction ressemble à ceci : Declare Function GetLastError& Lib « kernel32 » ()

   ATTENTION! Lorsque vous travaillez en VB, il est préférable d'utiliser la propriété LastDLLError de l'objet Err pour obtenir la valeur du code d'erreur qualifié, car VB réinitialise parfois la fonction GetLastError entre l'appel de l'API et la poursuite de l'exécution du programme.

   Vous pouvez interpréter le code renvoyé par GelLastError à l'aide de constantes écrites dans le fichier API32.TXT, dont les noms commencent par le suffixe ERROR_.

   La plupart erreurs typiques avoir les codes suivants :

   • ERROR_INVALID_HANDLE = 6& - identifiant non valide
   • ERROR_CALL_NOT_IMPLEMENTED = 120& - appel d'une fonction dans Windows 9x qui n'est disponible que pour Windows NT
   • ERROR_INVALID_PARAMETER = 87& - valeur de paramètre incorrecte

   Cependant, de nombreuses fonctions renvoient la valeur d'un paramètre demandé (par exemple, OpenFile renvoie la valeur du descripteur de fichier). Dans de tels cas, l'erreur est déterminée par une autre valeur spéciale de Return&, le plus souvent 0 ou –1.

2. Les API Win32 utilisent des méthodes strictement fixes pour transférer les types de données les plus simples. a) ByVal... Tant que

   Au moins 80 % de la transmission des arguments est effectuée à l'aide de variables longues. Notez que l'argument Toujours est accompagné du mot-clé ByVal, ce qui signifie, entre autres, qu'un transfert de données unidirectionnel est effectué - du programme VB vers la fonction API.

   B) ByVal...En tant que chaîne

   Ce type de transfert de données se produit également assez souvent, et avec l'argument également Toujours ByVal s’applique. Lorsqu'une fonction API est appelée, l'adresse de la chaîne est écrite dans la pile, donc dans ce cas, un échange de données bidirectionnel est possible. Il y a plusieurs dangers dont il faut être conscient lorsque l’on travaille avec des cordes.

   La première est que la réservation de mémoire pour une chaîne est effectuée dans le programme appelant, donc si la fonction API remplit les chaînes, vous devez alors créer une chaîne de la taille requise avant de l'appeler. Par exemple, la fonction GetWindowsDirectory renvoie le chemin d'accès au répertoire Windows, qui, par définition, ne doit pas comporter plus de 144 caractères. Par conséquent, l’appel de cette fonction devrait ressembler à ceci :

   WinPath$ = Space$(144) ' réserver une chaîne de _ 144 caractères Result& = GetWindowsDirectory& (WinTath$, 144) _ ' remplir le tampon ' Result& - le nombre réel de caractères dans le _ nom du répertoire WinPath$ = Left$(WinPath , Résultat&)

   Le deuxième problème est que lors de l'appel d'une fonction API, la chaîne source est convertie en une représentation interne, et vice versa lors de la sortie de la fonction. Si à l'époque de Win16 cette opération consistait uniquement à ajouter un octet zéro à la fin de la ligne, alors avec l'avènement de Win32, cela a été ajouté à la transformation du codage Unicode double octet en ANSI et vice versa. (Ceci a été discuté en détail dans l'article « Caractéristiques du travail avec des variables de chaîne en VB », ComputerPress 10'99 et 01'2000). Pour l'instant, notons simplement qu'en utilisant la construction ByVal ... As String, vous pouvez échanger des chaînes avec uniquement des données de caractères.

   B) ... Comme n'importe quel autre

   Cela signifie qu'une adresse de tampon mémoire sera poussée sur la pile, dont le contenu sera interprété par la fonction API, par exemple, en fonction de la valeur d'autres arguments. Cependant, As Any ne peut être utilisé que dans l'instruction Declare - lorsqu'une fonction spécifique est appelée, une variable spécifique doit être définie comme argument.

   D) ... En tant que type défini par l'utilisateur

   Cette conception est également souvent utilisée lorsqu'il est nécessaire d'échanger des données (généralement dans les deux sens) en utilisant une certaine structure. En fait, cette construction est une sorte de mise en œuvre concrète de la forme de transmission As Any, c'est juste que dans ce cas la fonction est configurée selon une structure fixe.

   La forme de la structure des données est déterminée par la fonction API spécifique, et il est de la responsabilité du programmeur de la décrire correctement et de la réserver dans le programme appelant. Cette conception Toujours utilisé sans mots ByVal, c'est-à-dire que dans ce cas, un transfert par référence est effectué - l'adresse de la variable est écrite dans la pile.

Exemple d'appel d'une fonction API

Illustrons ce qui précède en utilisant l'exemple de l'utilisation de deux fonctions utiles travailler avec des fichiers - lopen et lread, qui sont décrits comme suit :

Déclarer la fonction lopen Lib « kernel32 » _ Alias ​​​​« _lopen » (_ ByVal lpFileName As String, _ ByVal wReadWrite As Long) As Long Déclarer la fonction lread Lib « kernel32 » _ Alias ​​​​« _lread » (_ ByVal hFile As Long, lpBuffer As Any, _ ByVal wBytes As Long) As Long

En VB, leurs analogues - dans ce cas précis - sont les opérateurs Open et Get (pour le mode Binaire). Faisons immédiatement attention à l'utilisation du mot-clé Alias ​​​​dans une déclaration de fonction - c'est exactement le cas lorsque vous ne pouvez pas vous en passer. Les noms de fonctions réels dans la bibliothèque commencent par un trait de soulignement (style typique du langage C), ce qui n'est pas autorisé dans VB.

L'opération d'ouverture du fichier pourrait ressembler à ceci :

Const INVALID_HANDLE_VALUE = -1 ' valeur de descripteur _ incorrecte lpFileName$ = “D:\calc.bas” ' nom de fichier wReadWrite& = 2 ' mode lecture-écriture hFile& = lopen(lpFileName$, wReadWrite&) _ ' définit le descripteur de fichier Si hFile& = INVALID_HANDLE_VALUE Puis _ 'erreur d'ouverture du fichier ' précisez le code d'erreur CodeError& = Err.LastDllError 'CodeError& = GetLastError _ ' cette construction ne fonctionne pas Fin Si

Ici, vous devez faire attention à deux points :

• comme valeur de la fonction, nous obtenons la valeur du descripteur de fichier. L'erreur correspond à une valeur de –1 ;
• C'est précisément dans ce cas que l'appel de la fonction GetLastError ne fonctionne pas - pour obtenir une valeur d'erreur affinée, nous nous sommes tournés vers l'objet Err (nous avons évoqué la possibilité d'une telle situation ci-dessus).

Le contenu du fichier peut alors être lu, mais cela suppose que le programmeur ait une certaine compréhension de sa structure (comme c'est le cas lorsqu'il travaille avec des fichiers binaires arbitraires). Dans ce cas, l’appel de la fonction lread pourrait ressembler à ceci :

Dim MyVar As Single wBytes = lread (hFile&, MyVar, Len(MyVar) ' lecture d'un nombre réel, 4 octets ' wBytes est le nombre de données réellement lues, ' -1 est une erreur... Tapez MyStruct x As Single i As Entier Fin Type Dim MyVar As MyStruct wBytes = lread (hFile&, MyVar, Len(MyVar)) ' lire la structure de données, 6 octets

Attention encore : le deuxième argument de la fonction est passé par référence, le reste est passé par valeur.

Dim MyVar As String MyVar = Space$(10) 'réserver une variable pour 10 caractères wBytes = lread (hFile&, ByVal MyVar, Len(MyVar)) ' lire une chaîne de caractères, 10 caractères

Ici, vous pouvez voir une différence importante par rapport à l'exemple précédent : la variable chaîne est nécessairement accompagnée du mot-clé ByVal.

La lecture du contenu d'un fichier dans un tableau (pour plus de simplicité, nous utiliserons un tableau d'octets unidimensionnel) se fait de la manière suivante :

Dim MyArray(1 To 10) As Byte wBytes = lread (hFile&, MyArray(1), _ Len(MyArray(1))* 10) ‘ lire 10 éléments du tableau

En spécifiant le premier élément du tableau en argument, on passe l'adresse du début de la zone mémoire réservée au tableau. Évidemment, vous pouvez remplir n'importe quel fragment d'un tableau de cette manière :

WBytes = lread (hFile&, MyArray(4), _ Len(MyArray(1))* 5) ‘ lire les éléments du tableau 4 à 8

Astuce 5 : utilisez Alias ​​​​pour Gears et paramètres comme n'importe quel

Ici, sur la base de l'exemple précédent, nous révélerons l'essence du quatrième conseil de Dan Appleman.

Lorsque vous travaillez avec la fonction lread, n'oubliez pas que lorsque vous y accédez à l'aide d'une variable chaîne, vous devez utiliser le mot-clé ByVal (sinon vous recevrez des messages concernant une opération illégale). Pour vous protéger, vous pouvez faire une description spéciale supplémentaire de la même fonction pour fonctionner uniquement avec des variables chaîne :

Déclarez la fonction lreadString Lib « kernel32 » _ Alias ​​​​« _lread » (_ ByVal hFile As Long, ByVal lpBuffer As String, _ ByVal wBytes As Long) As Long

Lorsque vous travaillez avec cette description, vous n'avez plus besoin de spécifier ByVal lorsque vous contactez :

WBytes = lreadString(hFile&, MaVarString, _ Len(MaVarString)) '

Il semblerait que la syntaxe de l'opérateur Declare permette de faire une description spéciale similaire pour un tableau :

Déclarez la fonction lreadString Lib « kernel32 » Alias ​​​​« _lread » (_ ByVal hFile As Long, lpBuffer() As Byte, _ ByVal wBytes As Long) As Long

Cependant, l'appel

WBytes = lreadArray(hFichier&, MonArray(), 10)

conduit inévitablement à une erreur de programme fatale.

Ceci est la suite de la conversation sur les particularités du traitement des variables de chaîne dans Visual Basic : VB utilise le codage Unicode sur deux octets, Win API utilise ANSI sur un octet (et avec le format adopté en C - avec un octet zéro à la fin) . Par conséquent, lors de l'utilisation de variables chaîne comme argument, la conversion d'Unicode en ANSI est toujours automatiquement effectuée lors de l'appel d'une fonction API (plus précisément, une fonction DLL) et la conversion inverse lors du retour.

La conclusion est simple : les variables de chaîne peuvent être utilisées pour échanger des données de caractères, mais elles ne peuvent pas être utilisées pour échanger des informations binaires arbitraires (comme c'était le cas avec les versions 16 bits de VB). Dans ce dernier cas, il est préférable d’utiliser un tableau d’octets unidimensionnel.

Comme vous le savez, le type String peut être utilisé pour décrire une structure personnalisée. À cet égard, vous devez vous rappeler ce qui suit :

• Il est strictement interdit d'utiliser la construction suivante pour accéder à l'API Win : Tapez MyStruct x As Single s As String 'string de longueur variable End Type

  Dans le cas d'une chaîne de longueur variable, un descripteur de chaîne est passé dans la structure avec toutes les conséquences qui en découlent sous la forme d'une erreur d'exécution du programme.

• Vous pouvez utiliser une chaîne de longueur fixe comme élément de structure : Tapez MyStruct x As Single s As String*8 ‘ chaîne de longueur fixe End Type

Dans ce cas, la conversion de codage correspondante est effectuée.

Et une dernière remarque : vous ne devez en aucun cas utiliser un tableau de variables de chaîne (de longueur fixe et variable) lorsque vous accédez à une fonction API. Dans le cas contraire, l'émergence d'une « opération illégale » sera garantie.

Il est probable que vous vous retrouverez dans une situation où vous devrez écrire vos propres fonctions DLL. Cela sera inévitablement nécessaire si vous utilisez une technologie de programmation mixte - en utilisant deux ou plusieurs langages de programmation pour implémenter une seule application.

A ce propos, on note que la programmation mixte est assez courante pour mettre en œuvre une application assez complexe. En effet, chaque langage (plus précisément, un système de programmation basé sur un langage) possède ses propres forces et faiblesses, il est donc tout à fait logique de profiter de divers outils pour résoudre différentes tâches. Par exemple, VB - pour créer une interface utilisateur, C - pour un accès efficace aux ressources système, Fortran - pour implémenter des algorithmes numériques.

L'avis de l'auteur est le suivant : toute programmation sérieuse nécessite que le développeur maîtrise au moins deux outils. Bien sûr, dans les conditions modernes de division claire du travail, il est très difficile d'être un excellent expert, même dans deux systèmes, c'est pourquoi le schéma des « langues principales et auxiliaires » est plus logique. L’idée ici est que même une connaissance superficielle de la langue « auxiliaire » (écriture de procédures assez simples) peut grandement améliorer l’efficacité d’utilisation de la langue « principale ». Notez que la connaissance de VB, au moins à titre auxiliaire, est aujourd'hui presque une exigence obligatoire pour un programmeur professionnel. À propos, à l'époque du DOS, la connaissance des bases d'Assembler était extrêmement souhaitable pour tout programmeur, y compris Basic.

D'une manière ou d'une autre, même dans le travail de groupe, lorsque chaque programmeur est engagé dans sa propre tâche spécifique, une idée des caractéristiques de l'interface procédurale dans différentes langues tous les participants au projet doivent l'avoir. Et sachez que de nombreux systèmes de programmation (dont VB), en plus de l'interface par défaut, permettent d'utiliser d'autres méthodes avancées d'accès aux procédures qui permettent d'adapter l'interface à un autre langage.

Lors de l'étude de l'interface interprocédurale, vous devez prêter attention aux pièges possibles suivants :

• Différentes langues peuvent utiliser différentes conventions pour écrire les identifiants. Par exemple, il est courant d'utiliser un trait de soulignement au début du nom d'une procédure, ce qui n'est pas autorisé en VB. Ce problème est facilement résolu en utilisant le mot-clé Alias ​​​​dans l'instruction Declare (voir exemple astuce 2.3).
• Une séquence différente d'écriture des arguments transmis sur la pile peut être utilisée. Par exemple, à l'époque de DOS (je l'avoue honnêtement, je ne sais pas à quoi cela ressemble maintenant dans l'environnement Windows), C écrivait des arguments à partir de la fin de la liste, d'autres langages (Fortran, Pascal, Basic) - Depuis le début.
• Par défaut, différents principes de transmission des paramètres sont utilisés - par référence ou par valeur.
• Divers principes pour stocker les variables de chaîne. Par exemple, en C (ainsi qu'en Fortran et Pascal), la longueur d'une chaîne est déterminée par l'octet nul à la fin de celle-ci, mais en Basic, la longueur est écrite explicitement dans le descripteur de chaîne. Bien entendu, vous devez garder à l’esprit la possibilité d’utiliser différents codages de caractères.
• Lors du transfert de tableaux multidimensionnels, n'oubliez pas que diverses options de conversion de structures multidimensionnelles en structures unidimensionnelles sont possibles (à partir du premier index ou du dernier, par rapport aux tableaux bidimensionnels - "par lignes" ou "par colonnes" ).

Compte tenu de tout cela, les recommandations suivantes peuvent être formulées :

• Utilisez les méthodes les plus simples et éprouvées pour transmettre des arguments aux fonctions DLL. Les standards adoptés pour l’API Win conviennent tout à fait comme modèle.
• Ne transmettez jamais de tableaux de variables de chaîne.
• Soyez très prudent lorsque vous transmettez des variables de chaîne simples et des tableaux multidimensionnels.
• Assurez-vous de vérifier spécialement la fonctionnalité du mécanisme permettant de transmettre des arguments à la procédure appelée et inversement. Écrivez un test spécial pour vérifier le transfert de données. Vérifiez séparément que chaque argument est passé correctement. Par exemple, si vous avez une procédure avec plusieurs arguments, vérifiez d'abord que chaque paramètre est passé correctement pour l'option à un argument, puis seulement pour la liste entière.

Mais que se passe-t-il si la fonction DLL est déjà écrite, par exemple, en Fortran, mais que son interface d'entrée ne s'intègre pas très bien dans les normes VB ci-dessus ? Il y a deux conseils ici. Premièrement : écrivez une fonction DLL de test et utilisez-la pour essayer de trouver l'appel souhaité à partir du programme VB par essais et erreurs. Deuxièmement : écrire une procédure d'adaptateur dans le même Fortran qui fournirait une interface simple entre VB et une fonction DLL avec la conversion de structures de données simples en structures complexes (par exemple, convertir un tableau d'octets multidimensionnel en un tableau de chaînes).

Donc : utilisez les fonctions DLL. Mais restez vigilant...

OrdinateurPress 9"2000

Tôt ou tard, tout programmeur est confronté à un concept tel que API. Cependant, lorsqu’une telle réunion a lieu, tout le monde ne sait pas de quoi il s’agit, pourquoi elle est nécessaire et comment l’utiliser. Et dans cet article je vais combler cette lacune dans les connaissances de certains d'entre vous, et aussi donner un exemple tiré de ma pratique.

API (Interface de programmation d'applications) - Ce Interface de programmation d'applications. Plus précisément dans un langage simple, il s'agit alors d'un ensemble de diverses fonctions, constantes, classes, formats de requête qui peuvent être utilisés dans d'autres programmes.

On peut considérer que API- il s'agit d'un certain objet dont nous ne connaissons pas la mise en œuvre, mais nous pouvons l'utiliser. Par exemple, un ordinateur est un objet dont très peu de gens connaissent la mise en œuvre, mais presque tout le monde peut l'utiliser pour effectuer certaines actions : regarder des vidéos, surfer sur Internet, imprimer du texte, etc. Peu de gens savent comment cela fonctionne, mais presque tout le monde peut le faire.

Exemple API est API Windows, API OpenGL, API Direct3D et ainsi de suite.

Par exemple, il n'y a pas si longtemps, j'ai aussi rencontré directement API. Je me suis inscrit au service de liste de diffusion" SmartResponder.ru" et a lancé une newsletter à laquelle les gens ont commencé à s'abonner. La tâche était la suivante : dans les 24 heures suivant son inscription, une personne peut acheter mon cours vidéo payant à prix réduit. Puisque toutes les informations sur les abonnés sont stockées sur le serveur " SmartResponder.ru", puis un accès normal (par exemple, via Base de données) Je n'avais pas accès à ces données, mais il fallait les mettre en œuvre. Heureusement, " SmartResponder.ru"Ayez le vôtre API, que j'ai utilisé.

J'ai trouvé en eux API format de requête pour obtenir la date d'abonnement en conséquence. Plus loin boucle J'ai envoyé la demande correspondante et reçu la date de souscription souhaitée pour un adresses mail. Vient ensuite le traitement standard et la sortie du résultat.

bac à sable

dur à cuire 26 novembre 2012 à 13h59

Qu'est-ce qu'une API

• Débarras *

Salutations!
Dans cet article, nous verrons ce qu'est une API, où, comment et pour quoi elle est utilisée. Nous verrons également comment l'API peut être utilisée dans vos développements web et comment elle peut vous simplifier la vie. développeur web toi.

Commençons donc par la définition. L'API (Application Programming Interface) est une interface de programmation, une interface de création d'applications. Plus précisément en langage clair, alors l'API est un code prêt à l'emploi pour faciliter la vie du programmeur. L'API a été créée pour qu'un programmeur puisse réellement faciliter la tâche d'écriture d'une application en utilisant du code prêt à l'emploi (par exemple, des fonctions). Le célèbre jQuery, écrit en JavaScript, est aussi une sorte d'API. Si l'on regarde spécifiquement cet exemple, alors jQuery rend l'écriture de code beaucoup plus facile. Ce qui pourrait être fait en utilisant des outils JavaScript classiques en 30 lignes est écrit en 5-6 à l'aide de jQuery. Si nous regardons les API en général, nous pouvons trouver de nombreux services qui fournissent des solutions de développement. Le plus connu aujourd’hui est le service code.google.com, qui propose une cinquantaine d’API différentes ! Cela inclut une interface pour créer des applications Android, diverses API pour travailler avec AJAX et diverses API d'application qui peuvent être facilement personnalisées à votre guise.

Après tout, est-il judicieux d’écrire du code soi-même ? Pourquoi travailler sur ce qui a déjà été créé ? Y a-t-il un intérêt à abandonner ? solutions gratuites(et en fait, d'une aide gratuite) en développement web ? Si vous avez répondu « NON » à toutes ces questions, alors considérez que vous comprenez l'essence de l'API.

Mais je veux aussi faire une réservation. Les développeurs débutants ne devraient PAS utiliser de solutions à moitié cuites, car ils ne résoudront pas le vrai problème à l'avenir. Par conséquent, si vous web pour débutants programmeur, alors n'utilisez pas de produits semi-finis ! Apprenez à penser avec votre propre tête, construisez divers algorithmes pour comprendre l'essence de la programmation. Je dis aussi, en m'adressant déjà à tout le monde, que l'API n'est pas solutions prêtes à l'emploi, c'est un environnement, une interface pour créer vos projets. Vous ne mangez pas de côtelettes surgelées du magasin, n'est-ce pas ? Vous les faites frire d'abord, n'est-ce pas ? Cette analogie capture très clairement l’essence de l’API.

De manière générale, je vous ai expliqué ce qu'est une API, où et comment elle est utilisée et surtout pourquoi. Amusez-vous à étudier programmation web et la compréhension de ses profondeurs toujours plus grandes !

Mots clés : API

Cet article ne fait pas l'objet de commentaires, son auteur n'étant pas encore membre à part entière de la communauté. Vous ne pourrez contacter l'auteur qu'après réception

Ce court terme entendu par tous ceux qui ont eu une expérience en matière de développement. Mais tout le monde ne comprend pas exactement ce que cela signifie et pourquoi cela est nécessaire. Développeur Pierre Gazarov a parlé de l'API avec des mots simples sur son blog.

L'abréviation API signifie "Application Programming Interface". interface logicielle applications). Majorité grandes entreprisesà un certain stade, des API sont développées pour les clients ou pour usage interne. Pour comprendre comment et comment les API sont utilisées dans le développement et les affaires, vous devez d'abord comprendre le fonctionnement du World Wide Web.

World Wide Web et serveurs distants

Le WWW peut être considéré comme un immense réseau de serveurs interconnectés sur lequel chaque page est stockée. Ordinateur portable ordinaire peut être transformé en un serveur capable de desservir un site Web entier sur le réseau, et serveurs locaux les développeurs l'utilisent pour créer des sites Web avant de les mettre à la disposition du public.

Une fois entré dans la barre d'adresse du navigateur www.facebook.com Une requête correspondante est envoyée au serveur Facebook distant. Une fois que le navigateur reçoit la réponse, il interprète le code et affiche la page.

Chaque fois qu'un utilisateur visite une page sur le Web, il interagit avec l'API serveur distant. L'API est le composant du serveur qui reçoit les requêtes et envoie les réponses.

L'API comme moyen de servir les clients

De nombreuses entreprises proposent des API sous forme de produits prêts à l'emploi. Par exemple, Weather Underground vend l'accès à son API de données météorologiques.

Scénario d'utilisation : Sur le site Internet d'une petite entreprise, il existe un formulaire de prise de rendez-vous pour les clients. L'entreprise souhaite y intégrer Google Agenda pour donner aux clients la possibilité de créer automatiquement un événement et de saisir les détails d'une réunion à venir.

Application API : L'objectif est que le serveur du site contacte directement le serveur Google avec une demande de création d'un événement avec les détails spécifiés, reçoit la réponse de Google, la traite et envoie les informations appropriées au navigateur, par exemple un message de confirmation à l'utilisateur. .

Alternativement, le navigateur peut faire une requête à l'API Serveurs Google, en contournant le serveur de l'entreprise.

En quoi l'API de Google Calendar est-elle différente de l'API de tout autre serveur distant du réseau ?

Techniquement, la différence réside dans le format de la demande et de la réponse. Pour générer une page Web complète, le navigateur attend une réponse dans la langue Balisage HTML, tandis que l'API Google Calendar renverra simplement les données dans un format tel que JSON.

Si une requête à l'API est faite par le serveur du site Internet d'une entreprise, alors il s'agit du client (tout comme le navigateur est le client lorsque l'utilisateur ouvre le site Internet).

Grâce à l’API, l’utilisateur a la possibilité d’effectuer une action sans quitter le site Internet de l’entreprise.

La plupart des sites Web modernes utilisent au moins quelques API tierces. De nombreuses tâches disposent déjà de solutions toutes faites proposées par des développeurs tiers, qu'il s'agisse d'une bibliothèque ou d'un service. Il est souvent plus simple et plus fiable de recourir à une solution toute faite.

De nombreux développeurs distribuent l'application sur plusieurs serveurs, qui interagissent entre eux à l'aide de l'API. Les serveurs qui remplissent une fonction de support pour le serveur d'applications principal sont appelés microservices.

Ainsi, lorsqu’une entreprise propose une API à ses utilisateurs, cela signifie simplement qu’elle a créé une série d’URL spéciales qui renvoient uniquement des données en réponse.

De telles demandes peuvent souvent être envoyées via un navigateur. Étant donné que le transfert de données HTTP s'effectue sous forme de texte, le navigateur pourra toujours afficher la réponse. Par exemple, via un navigateur, vous pouvez accéder directement à l'API GitHub (https://api.github.com/users/petrgazarov), sans jeton d'accès, et recevoir cette réponse au format JSON :

Le navigateur affiche parfaitement la réponse JSON, qui peut être insérée dans le code. Il est assez simple d'extraire des données d'un tel texte et de les utiliser à votre discrétion.

Quelques autres exemples d'API

Le mot « application » peut être utilisé dans différentes significations. Dans le contexte de l'API, cela signifie :

• fragment logiciel avec une fonction spécifique,
• l'ensemble du serveur, l'ensemble de l'application ou simplement une partie distincte de l'application.

Tout logiciel pouvant être clairement distingué de l'environnement peut remplacer la lettre « A » dans une abréviation anglaise et peut également disposer d'une sorte d'API. Par exemple, lorsqu'un développeur implémente une bibliothèque tierce dans le code, celle-ci devient partie intégrante de l'ensemble de l'application. En tant que logiciel autonome, la bibliothèque disposera d'une sorte d'API qui lui permettra d'interagir avec le reste du code de l'application.

Dans la conception orientée objet, le code est représenté comme un ensemble d’objets. Dans une application, des centaines d’objets de ce type peuvent interagir les uns avec les autres. Chacun d'eux a sa propre API - un ensemble publique propriétés et méthodes d'interaction avec d'autres objets de l'application. Les objets peuvent également avoir privé, une logique interne cachée à l'environnement et qui n'est pas une API.