Qu'est-ce qu'un logiciel efficace ? Un logiciel efficace doit non seulement fonctionner plus rapidement qu’un logiciel remplissant la même fonction, mais doit également consommer moins de ressources système. Cet article rassemble une partie de l'expérience accumulée par l'auteur lors de l'utilisation de VB pour le développement de logiciels et utilise quelques exemples simples pour vous montrer comment écrire du code VB efficace. Il contient certaines techniques qui peuvent être très utiles aux programmeurs VB. Avant de commencer, permettez-moi de clarifier quelques concepts.
Laissez le code prendre forme immédiatement : parmi les programmeurs avec lesquels j'ai été en contact, de nombreuses personnes aiment d'abord écrire le code en fonction des exigences fonctionnelles, puis optimiser le code sur cette base. En fin de compte, ils ont constaté que pour parvenir à l’optimisation, ils devaient réécrire le code. Je vous suggère donc de considérer les problèmes d'optimisation avant d'écrire du code.
Comprenez la relation entre les résultats de l'optimisation et le travail requis : généralement lorsqu'un morceau de code est terminé, vous devez l'inspecter et le modifier. Au cours du processus d'inspection du code, vous constaterez peut-être que l'efficacité du code dans certaines boucles peut être encore améliorée. Dans ce cas, de nombreux programmeurs en quête de perfection peuvent modifier le code immédiatement. Ma suggestion est que si la modification de ce code réduit la durée d'exécution du programme d'une seconde, vous pouvez le modifier. Si cela ne peut apporter qu’une amélioration des performances de 10 millisecondes, aucun changement ne sera apporté. En effet, la réécriture d'un morceau de code introduira inévitablement de nouvelles erreurs, et le débogage d'un nouveau code vous prendra certainement un certain temps. Les programmeurs doivent trouver un équilibre entre les performances du logiciel et la quantité de travail requise pour développer le logiciel, et 10 millisecondes sont une différence que les utilisateurs ne peuvent pas apprécier.
Essayez d'utiliser des méthodes orientées objet lorsque vous en avez besoin ; le mécanisme fourni par VB ne prend pas entièrement en charge la conception et le codage orientés objet, mais VB fournit des classes simples. La plupart des gens pensent que l’utilisation d’objets entraînera un code moins efficace. Personnellement, j'ai des opinions différentes sur ce point ; l'efficacité du code ne peut pas être évaluée uniquement du point de vue de la vitesse d'exécution. Les ressources occupées par le logiciel sont également l'un des facteurs à prendre en compte. L'utilisation de classes peut vous aider à améliorer les performances globales de votre logiciel, ce que j'expliquerai en détail dans des exemples ultérieurs.
Lorsque vous écrivez du code VB, j'espère que vous pourrez utiliser les points ci-dessus comme principes pour guider votre codage. J'ai divisé l'article en deux parties : comment améliorer la vitesse d'exécution du code et l'optimisation de la compilation.
Comment rendre votre code plus rapide
Les méthodes suivantes peuvent vous aider à améliorer la vitesse de votre code :
1. Utilisez des entiers (Integer) et des entiers longs (Long)
Le moyen le plus simple d’accélérer l’exécution de votre code est d’utiliser les bons types de données. Vous ne le croirez peut-être pas, mais choisir le bon type de données peut grandement améliorer les performances de votre code. Dans la plupart des cas, les programmeurs peuvent remplacer les variables de type Simple, Double et Devise par des variables de type Integer ou Long, car la capacité de VB à gérer Integer et Long est bien supérieure à celle des autres types de données.
Dans la plupart des cas, la raison pour laquelle les programmeurs choisissent d'utiliser Single ou Double est leur capacité à enregistrer des décimales. Mais les décimales peuvent également être stockées dans des variables de type Integer. Par exemple, s'il y a trois décimales convenues dans le programme, il vous suffit de diviser la valeur stockée dans la variable entière par 1 000 pour obtenir le résultat. D'après mon expérience, le code peut s'exécuter près de 10 fois plus rapidement en utilisant Integer et Long au lieu de Single, Double et Currency.
2. Évitez d'utiliser des variantes
Pour un programmeur VB, c'est une évidence. Les variables de types variants nécessitent 16 octets d'espace pour stocker les données, tandis qu'un entier (Integer) ne nécessite que 2 octets. Habituellement, l'objectif de l'utilisation de types de variantes est de réduire la charge de travail de conception et la quantité de code. Certains programmeurs l'utilisent également pour éviter des problèmes. Mais si un logiciel est strictement conçu et codé selon des spécifications, l’utilisation de types variantes peut être complètement évitée.
À propos, le même problème existe également pour les objets Object. Veuillez regarder le code ci-dessous :
mOFS
SetFSO=NewScripting.FileSystemObject
ou
DimFSOasobject
SetFSO=NewScripting.FileSystemObject
Étant donné que le code ci-dessus ne spécifie pas le type de données lors de la déclaration, la mémoire et le temps CPU seront gaspillés lors de l'affectation. Le code correct devrait ressembler à ceci :
DimFSOasNewFileSystemObject
3. Essayez d'éviter d'utiliser des attributs
Dans le code quotidien, le code inefficace le plus courant consiste à utiliser à plusieurs reprises des propriétés (Property) lorsque des variables peuvent être utilisées, notamment dans les boucles. Il faut savoir que la vitesse d'accès aux variables est environ 20 fois supérieure à celle d'accès aux attributs. Le code suivant est utilisé par de nombreux programmeurs dans leurs programmes :
DimintConasInteger
ForintCon=0versUbound(SomVar())
Text1.Text=Text1.Text&vbcrlf&SomeVar(intCon)
SuivantintCon
Le code ci-dessous s'exécute 20 fois plus vite que le code ci-dessus.
DimintConasInteger
DimsOutputasString
ForintCon=0toUbound(SomeVar())
sOutput=sOutput&vbCrlf&
UneVar(intCon)
Suivant
Text1.Text=sSortie
4. Essayez d'utiliser des tableaux et évitez d'utiliser des ensembles
Sauf si vous devez utiliser une collection, vous devez toujours utiliser un tableau. Selon les tests, la vitesse d'accès aux tableaux peut atteindre 100 fois celle des collections. Ce chiffre semble un peu choquant, mais si l’on considère qu’une collection est un objet, vous comprendrez pourquoi la différence est si grande.
5. Développez le petit corps en boucle
Lors du codage, vous pouvez rencontrer cette situation : un corps de boucle ne bouclera que 2 ou 3 fois, et le corps de la boucle est constitué de plusieurs lignes de code. Dans ce cas, vous pouvez dérouler la boucle. La raison en est que la boucle prend du temps CPU supplémentaire. Mais si la boucle est plus complexe, vous n’avez pas besoin de le faire.
6. Évitez d'utiliser des fonctions très courtes
Comme pour l'utilisation de petites boucles, il n'est pas rentable d'appeler une fonction avec seulement quelques lignes de code : l'appel de la fonction peut prendre plus de temps que l'exécution du code dans la fonction. Dans ce cas, vous pouvez copier le code de la fonction à l'endroit où la fonction a été initialement appelée.
7. Réduire les références aux sous-objets
En VB, les références d'objet sont implémentées à l'aide de . Par exemple:
Formulaire1.Texte1.Texte
Dans l'exemple ci-dessus, le programme fait référence à deux objets : Form1 et Text1. Citer en utilisant cette méthode est inefficace. Mais malheureusement, il n’y a aucun moyen de l’éviter. La seule chose que le programmeur peut faire est d'utiliser With ou de sauvegarder l'objet enfant (Text1) avec un autre objet.
Remarque : à utiliser avec
AvecfrmMain.Text1
.Text="Apprendre VB"
.Alignement=0
.Tag="C'est ma vie"
.BackColor=vbNoir
.ForeColor=vbBlanc
FinPar
ou
Remarque : utilisez un autre objet pour enregistrer l'objet enfant
DimtxtTextBoxasTextBox
SettxtTextBox=frmMain.Text1
TxtTextBox.Text="ApprendreVB"
TxtTextBox.Alignment=0
TxtTextBox.Tag="C'est ma vie"
TxtTextBox.BackColor=vbBlack
TxtTextBox.ForeColor=vbWhite
Notez que la méthode mentionnée ci-dessus n'est applicable que lorsque vous devez opérer sur des sous-objets d'un objet. Le code suivant est incorrect :
AvecTexte1
.Text="Apprendre VB"
.Alignement=0
.Tag="C'est ma vie"
.BackColor=vbNoir
.ForeColor=vbBlanc
FinPar
Malheureusement, nous pouvons souvent trouver du code similaire à celui ci-dessus dans le code réel. Cela ne fera que ralentir l’exécution du code. La raison en est que le bloc With formera une branche après la compilation, ce qui ajoutera un travail de traitement supplémentaire.
8. Vérifiez si la chaîne est vide
La plupart des programmeurs utilisent la méthode suivante pour vérifier si une chaîne est vide :
IfText1.Text=""alors
Remarque : effectuer des opérations
Fin
Malheureusement, effectuer des comparaisons de chaînes nécessite encore plus de traitement que lire des propriétés. Je vous suggère donc d'utiliser la méthode suivante :
SiLen(Texte1.Texte)=0alors
Remarque : effectuer des opérations
Fin
9. Nom de la variable après suppression du mot-clé suivant
L'ajout du nom de la variable après le mot-clé Next entraînera une diminution de l'efficacité du code. Je ne sais pas pourquoi cela arrive, c'est juste une expérience. Mais je pense que très peu de programmeurs iraient jusqu'à ajouter des informations superflues. Après tout, la plupart des programmeurs sont des gens qui chérissent les mots comme l'or.
Commentaire : code erroné
ForiCount=1à10
Remarque : effectuer des opérations
SuivantiCount
Remarque : code correct
ForiCount=1à10
Remarque : effectuer des opérations
Suivant
10. Utilisez des tableaux au lieu de plusieurs variables
Lorsque vous disposez de plusieurs variables contenant des données similaires, envisagez de les remplacer par un tableau. En VB, les tableaux sont l'une des structures de données les plus efficaces.
11. Utilisez des tableaux dynamiques au lieu de tableaux statiques
L'utilisation de tableaux dynamiques n'aura pas un grand impact sur la vitesse d'exécution du code, mais dans certains cas, elle peut économiser beaucoup de ressources.
12. Détruisez les objets
Quel que soit le type de logiciel écrit, les programmeurs doivent envisager de libérer l'espace mémoire occupé par le logiciel une fois que l'utilisateur décide de mettre fin au logiciel. Mais malheureusement, de nombreux programmeurs ne semblent pas s'en soucier beaucoup. L'approche correcte consiste à détruire les objets utilisés dans le programme avant de quitter le programme. Par exemple:
DimFSOasNewFileSystemObject
Remarque : effectuer des opérations
Remarque : Détruisez l'objet
SetFSO=Rien
Pour les formulaires, vous pouvez désinstaller :
DéchargerfrmMain
ou
SetfrmMain=Rien
13. Chaînes de longueur variable et de longueur fixe
Techniquement parlant, les chaînes de longueur fixe nécessitent moins de temps et d'espace de traitement que les chaînes de longueur variable. Cependant, l'inconvénient des chaînes de longueur fixe est que dans de nombreux cas, vous devez appeler la fonction Trim pour supprimer le caractère nul à la fin de la chaîne, ce qui réduira l'efficacité du code. Donc, à moins que la longueur de la chaîne ne change pas, utilisez des chaînes de longueur variable.
14. Utilisez des modules de classe au lieu des contrôles ActiveX
À moins que les contrôles ActiveX n'impliquent des interfaces utilisateur, essayez d'utiliser des objets légers tels que des classes. Il y a une grande différence d’efficacité entre les deux.
15. Utiliser des objets internes
Lorsqu'il s'agit d'utiliser des contrôles ActiveX et des DLL, de nombreux programmeurs aiment les compiler puis les ajouter au projet. Je vous déconseille de faire cela car la connexion à un objet externe depuis VB nécessite beaucoup de puissance de traitement CPU. Chaque fois que vous appelez une méthode ou accédez à une propriété, vous gaspillez beaucoup de ressources système. Si vous disposez du code source d'un contrôle ActiveX ou d'une DLL, faites-en des objets privés dans le projet.
16. Réduisez le nombre de modules
Certaines personnes aiment conserver les fonctions communes dans des modules, et je suis d'accord avec cela. Mais écrire seulement vingt ou trente lignes de code dans un module est un peu ridicule. Si vous n'avez pas vraiment besoin d'un module, essayez de ne pas l'utiliser. La raison en est que VB charge les modules en mémoire uniquement lorsque des fonctions ou des variables du module sont appelées ; ces modules sont déchargés de la mémoire lorsque l'application VB se termine. S'il n'y a qu'un seul module dans le code, VB n'effectuera qu'une seule opération de chargement, donc l'efficacité du code sera améliorée, à l'inverse, s'il y a plusieurs modules dans le code, VB effectuera plusieurs opérations de chargement, et l'efficacité de le code sera réduit.
17. Utiliser des tableaux d'objets
Lors de la conception d'interfaces utilisateur, les programmeurs doivent essayer d'utiliser des tableaux d'objets pour les contrôles du même type. Vous pouvez faire une expérience : ajoutez 100 PictureBox à la fenêtre, chacune avec un nom différent, et exécutez le programme. Créez ensuite un nouveau projet, ajoutez également 100 PictureBox à la fenêtre, mais cette fois utilisez un tableau d'objets, exécutez le programme, vous pouvez remarquer la différence dans le temps de chargement des deux programmes.
18. Utilisez la méthode Move
Lors du changement de position d'un objet, certains programmeurs aiment utiliser les propriétés Largeur, Hauteur, Haut et Gauche. Par exemple:
Image1.Largeur=100
Image1.Hauteur=100
Image1.Haut=0
Image1.Gauche=0
En fait, c'est très inefficace, car le programme modifie quatre propriétés, et après chaque modification, la fenêtre sera redessinée. La bonne approche consiste à utiliser la méthode Move :
Image1.Move0,0,100,100
19. Réduire l’utilisation des images
Les images occuperont beaucoup de mémoire et leur traitement nécessite également beaucoup de ressources CPU. Dans les logiciels, si possible, envisagez d'utiliser des couleurs d'arrière-plan au lieu d'images - bien sûr, il ne s'agit que du point de vue d'un technicien sur ce problème.
20. Utilisez ActiveXDLL au lieu des contrôles ActiveX
Si l'objet ActiveX que vous concevez n'implique pas d'interface utilisateur, utilisez ActiveXDLL.
Optimisation de la compilation
De nombreux programmeurs VB que j'ai rencontrés n'ont jamais utilisé les options de compilation ni essayé de comprendre les différences entre les options. Jetons un coup d'œil à la signification spécifique de chaque option.
1.P-code (pseudocode) et code natif
Vous pouvez choisir de compiler le logiciel en code P ou en code natif. L'option par défaut est le code natif. Alors, que sont le code P et le code natif ?
Code P : lors de l'exécution de code dans VB, VB compile d'abord le code en code P, puis interprète et exécute le code P compilé. Dans un environnement compilé, l’utilisation de ce code est plus rapide que le code natif. Après avoir sélectionné P-Code, VB place le pseudocode dans un fichier EXE lors de la compilation.
Code natif : Le code natif est une option introduite seulement après VB6. Lorsqu'il est compilé dans un fichier EXE, le code natif s'exécute plus rapidement que le code P. Après avoir sélectionné le code natif, VB utilise les instructions machine pour générer un fichier EXE lors de la compilation.
Lors de la compilation avec du code natif, je constate que des erreurs parfois inexplicables sont introduites. Mon code s'exécute parfaitement correctement dans l'environnement de compilation, mais le fichier EXE généré avec l'option code natif ne s'exécute pas correctement. Cela se produit généralement lorsqu'une fenêtre est déchargée ou qu'une fenêtre d'impression apparaît. J'ai résolu ce problème en ajoutant une instruction DoEvent au code. Bien sûr, la probabilité que cela se produise est très rare. Peut-être que certains programmeurs VB ne l'ont jamais rencontré, mais cela existe.
Il existe également plusieurs options en code natif :
a) Optimisation de la vitesse du code : cette option permet de compiler un fichier exécutable plus rapide, mais le fichier exécutable est plus volumineux. Recommandé
b) Optimisation de la taille du code : cette option permet de compiler un fichier exécutable plus petit, mais au détriment de la vitesse, elle n'est pas recommandée.
c) Aucune optimisation : cette option convertit uniquement le code P en code natif sans aucune optimisation. Peut être utilisé lors du débogage du code.
d) Optimisé pour Pentium Pro : Bien que cette option ne soit pas l'option par défaut dans le code natif, j'utilise généralement cette option. Le programme exécutable compilé avec cette option peut s'exécuter plus rapidement sur les machines PentiumPro et Pentium2 ou supérieures, mais sera légèrement plus lent sur les machines plus anciennes. Étant donné que l’utilisation du Pentium2 est désormais obsolète, il est recommandé à tout le monde d’utiliser cette option.
e) Générer des informations de débogage symboliques : cet élément génère des informations de débogage pendant le processus de compilation, permettant aux utilisateurs d'utiliser des outils tels que Visual C++ pour déboguer le code compilé. L'utilisation de cette option génère un fichier .pdf qui enregistre les informations d'indicateur dans le fichier exécutable. Cette option est utile lorsque le programme possède des fonctions API ou des appels DLL.
2. Optimisation avancée
Les paramètres de l'optimisation avancée peuvent vous aider à améliorer la vitesse de votre logiciel, mais ils peuvent parfois introduire des bugs, je vous recommande donc de les utiliser aussi prudemment que possible. S'il y a des corps de boucle relativement volumineux ou des opérations mathématiques complexes dans le code, la sélection de certains éléments dans l'optimisation avancée améliorera considérablement les performances du code. Si vous utilisez des fonctionnalités d'optimisation avancées, je vous recommande de tester rigoureusement les fichiers compilés.
a) En supposant qu'il n'y ait pas d'alias : cela peut améliorer l'efficacité d'exécution du code dans le corps de la boucle, mais si la valeur de la variable est modifiée via une référence de variable, comme l'appel d'une méthode, la référence de variable est utilisée comme paramètre de la méthode, et la valeur de la variable est modifiée dans la valeur de la méthode, une erreur sera générée. Il se peut simplement que le résultat renvoyé soit erroné ou qu'il s'agisse d'une erreur grave provoquant l'interruption du programme.
b) Annuler la vérification de liaison de tableau, annuler la vérification de dépassement d'entier et annuler la vérification d'erreur en virgule flottante : lorsque le programme est en cours d'exécution, si des erreurs sont détectées grâce à ces vérifications, le code de gestion des erreurs gérera ces erreurs. Mais si ces contrôles sont annulés, le programme ne pourra pas gérer une erreur. Vous ne devez utiliser ces options que si vous êtes sûr que les erreurs ci-dessus ne se produiront pas dans votre code. Ils amélioreront considérablement les performances du logiciel.
c) Autoriser les opérations à virgule flottante sans arrondi : La sélection de cette option permet au programme compilé de traiter les opérations à virgule flottante plus rapidement. Son seul inconvénient est qu'il peut conduire à des résultats incorrects lors de la comparaison de deux nombres à virgule flottante.
d) Annuler le contrôle de sécurité du PentiumFDIV : cette option est définie pour certaines anciennes puces Pentium et semble désormais obsolète