WinDev : apprendre à utiliser les procédures internes apparues à partir de Windev 20

Un billet de Jonathan Laurent

Avant-propos

Cet article traite des procédures internes qui sont apparues à partir de Windev 20. Les versions 19 et antérieures ne sont donc malheureusement pas concernées.

Les procédures internes

De temps en temps, le WLangage profite d'améliorations conséquentes qui lui redonnent un petit goût de fraicheur. Les procédures internes font partie de ces évolutions qui changent la donne. Je consacrerai (si je compte bien) trois articles aux procédures internes. Celui-ci qui les présente et deux autres qui permettront d'aller beaucoup plus loin.

Avant d'expliquer plus en détail, rappelons que dans Windev, on a plusieurs types de procédures :

• les procédures globales. Elles sont stockées dans une collection de procédures (fichier *.wdg) et elles peuvent être appelées de n'importe où dans le projet;
  
• les procédures locales. Elles sont stockées dans les fenêtres (fichier *.wdw) et elles peuvent être appelées de n'importe où dans le code de la fenêtre. Elles ne peuvent pas être utilisées ailleurs. On peut toutefois contourner cette règle de plusieurs manières différentes. Mais mon éthique du code propre m'interdit de le faire (sauf si je n'ai pas le choix parce que je suis tombé sur du code sale);
  
• les méthodes. Ce sont des procédures associées à une classe (fichier *.wdc). Elles peuvent être locales ou globales, publiques, protégées ou privées. Mais là, on rentre dans le domaine de la POO (Programmation Orientée Objet) et ce n'est pas le sujet de l'article;
  
• les procédures compilées dynamiquement. On utilise la fonction compile;
  
• les procédures appelées à la suite d'un événement sur un champ de l'application.
  

Et maintenant, nous avons les procédures internes qui peuvent être définies et utilisées dans les autres types de procédures citées précédemment. Mais une procédure interne peut aussi être définie dans une autre procédure interne.

Comment ça marche?

Un petit exemple étant plus efficace qu'une longue présentation, voici un exemple de procédure interne:

PROCEDURE ProcédureLocale()
PROCEDURE INTERNE ProcédureInterne()
RENVOYER "Hello world"
FIN

Trace(ProcédureInterne())

On définit ici une procédure locale qui s'appelle ProcédureLocale et dans celle-ci, on définit la procédure interne ProcédureInterne.

Dans quel cas s'en sert-on?

On s'en sert dans plusieurs cas.

Tout d'abord, on peut s'en servir pour avoir un joli code bien écrit, autodocumenté (si vous ne connaissez pas ce terme, il faudra que je fasse un article dessus) et qui respecte la convention DRY (Don't Repeat Yourself, un autre article à prévoir).

Le code suivant:
PROCEDURE ProcédureLocale()
POUR i = 1 _A_ 10
Trace(i)
Trace(i * i)
Trace(Racine(i + 1))
FIN

POUR i = 30 _A_ 40
Trace(i)
Trace(i * i)
Trace(Racine(i + 1))
FIN

POUR i = 80 _A_ 100
Trace(i)
Trace(i * i)
Trace(Racine(i + 1))
FIN

deviendrait
PROCEDURE ProcédureLocale()
PROCEDURE INTERNE TracerEntierSousToutesCesFormes(pEntier est entier)
Trace(pEntier)
Trace(pEntier * pEntier)
Trace(Racine(pEntier + 1))
FIN

POUR i = 1 _A_ 10
TracerEntierSousToutesCesFormes(i)
FIN

POUR i = 30 _A_ 40
TracerEntierSousToutesCesFormes(i)
FIN

POUR i = 80 _A_ 100
TracerEntierSousToutesCesFormes(i)
FIN


Le code devient ainsi plus clair, j'évite les répétitions de code.

On peut aussi s'en servir pour des usages plus avancés que je décrirai dans les articles suivants: les closures et ce que j'appellerai les pseudo-classes.

Premier piège et comment l'éviter

Plusieurs pièges vous attendent lors de l'utilisation des procédures internes. Voici le premier.

Une procédure interne ne peut pas appeler une autre procédure interne définie au même niveau qu'elle.
PROCEDURE ProcédureLocale()
PROCEDURE INTERNE PasLeDroit()
Trace("Hello world")
FIN

PROCEDURE INTERNE Test()
PasLeDroit() // Cela ne fonctionne pas
FIN

Test()

Mais on peut s'en sortir en utilisant une variable de type Procédure. En effet, une procédure interne est une procédure avant tout.

Notez que je préfixe le nom des procédures internes par un i dans mon exemple pour les distinguer des variables de type procédure.
PROCEDURE ProcédureLocale()
PasLeDroit est une procédure

PROCEDURE INTERNE iPasLeDroit()
Trace("Hello world")
FIN
PasLeDroit = iPasLeDroit

PROCEDURE INTERNE iTest()
PasLeDroit() // Cela fonctionne
FIN

iTest()


Conclusion

Cet article est une copie de l'article paru sur mon blog.

Voilà pour la première approche sur les procédures internes. Vous allez voir que ce n'est que la partie visible de l'iceberg et que de belles fonctionnalités bien cachées et non documentées vous attendent.

N'hésitez pas à me dire dans quel cas vous utilisez les procédures internes.

Merci pour votre lecture.