Discussion :

[horemheb]

Bonjour, toujours sur le même projet, je cherche à déplacer un PictureBox à chaque Tick d'un Timer. J'ai abouti au code suivant (qui ne peut pas marcher tel quel) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
Module Principal
    WithEvents Metronome As New System.Windows.Forms.Timer()    'création du Timer Metronome
 
    Sub main()
        Dim Fenetre As New Form1        'création d'une fenêtre 
        Dim Cellule1 As New PictureBox  'création d'une picturebox
 
        'initialisation cellule 1
        Fenetre.Controls.Add(Cellule1)
        With Cellule1
            .Location = New System.Drawing.Point(20, 50)
            .Size = New System.Drawing.Size(20, 20)
            .TabIndex = 0
            .Image = My.Resources.Cellule_Est
        End With
 
        'affichage initial
        Fenetre.Show()
        Cellule1.Refresh()
        System.Threading.Thread.Sleep(1000) 'juste pour visualiser le début
 
        Metronome.Interval = 500    'réglage métronome
        Metronome.Start()           'départ métronome
 
        'pour passer le temps en attendant les Ticks
        Do While 2 < 3
        Loop
 
    End Sub
 
    Sub Metronome_Tick(ByRef Dessin As PictureBox)  'pour déplacer la picturebox aux Ticks du métronome
        Dessin.Left += 1
        Dessin.Refresh()
    End Sub
 
End Module

Je ne vois pas comment passer le paramètre Cellule1 à la routine Metronome_Tick. Déclarer la variable Cellule1 comme Public ne me parait pas élégant. Pourriez-vous me mettre sur la voie ?
Merci

[ebastien]

Bonjour,

Puisque le Timer et la PictureBox se trouvent sur Form1, il me paraît plus logique de les définir et des les instancier dans le code correspondant à Form1. Les instance peuvent être créer dans l'événement Load de la Form par exemple. Dans ce cas, Picturebox serait une donnée Private de Form1 visible par le Timer.

eb.

[rv26t]

Bonjour,

Bonjour, toujours sur le même projet, je cherche à déplacer un PictureBox à chaque Tick d'un Timer. J'ai abouti au code suivant (qui ne peut pas marcher tel quel) :
...

Apparement vous êtes avec un projet application console.

Il ne faut pas faire de boucle While infinie.
Pour ouvrir votre fenêtre et la garder active procédez ainsi

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
Imports System.Windows.Forms
 
Module Module1
 
    Sub Main()
        Dim f As Form = New Form
        Application.Run(f)
    End Sub
 
End Module

Comme vous le suggére ebastien placer le reste du code dans la Form et son évènement Load.

[Edit]Une question tout de même pourquoi partir sur une application console pour utiliser une fenêtre? Faites une appli WinForm directement. (ou alors j'ai loupé quelque chose)[/Edit]

[horemheb]

Bonjour, vos propositions ne règleront pas mon souci de passage de paramètre. Ce code sert de test pour mettre en place correctement les éléments de mon projet. Mon objectif actuel (phase 2) est de déplacer "simultanément" plusieurs picturebox au moyen d'autant de timers. Il faut donc un passage d'argument entre le timer et la picturebox concernée, qu'ils soient dans le module Sub main ou le Form1_Load. Il me faudrait, à la suite de Metronome.Start() une instruction du genre Metronome(Cellule1) pour envoyer à la procédure Metronome_Tick le paramètre qui manque.
Merci de m'éclairer.
Bonne journée.

[Pol63]

vous faites un list(of picturebox) et dans le timer vous faites un for each dessus

si le déplacement est différent d'un picturebox à l'autre, il faut faire une classe ayant les paramètres du déplacement et le picturebox, puis un list(of cette_classe)

[horemheb]

vous faites un list(of picturebox) et dans le timer vous faites un for each dessus
si le déplacement est différent d'un picturebox à l'autre, il faut faire une classe ayant les paramètres du déplacement et le picturebox, puis un list(of cette_classe)

Ok Pol63 pour plusieurs mais avant il faut que j'y arrive avec un seul. Et je ne vois pas comment je peux passer mon paramètre Cellule pour que le Timer déclenche la procédure avec le bon passage de paramètre. D'autant plus nécessaire s'il y a plusieurs Timers et plusieurs procédures à gérer.

La procédure Sub Metronome_Tick attend un passage de paramètre qui n'est réalisé nulle part. Entre Metronome.Start() et Metronome_Tick(...) il manque quelque chose, ou procéder autrement. Quoi, comment, je ne sais pas.
Est-ce bien Metronome_Tick qui est déclenché au tick du métronome ?
Comment passer des paramètres à un évènement ?
C'est sur ces points que je souhaiterais avoir des précisions.

[Pol63]

on écrit pas ce qu'on veut dans le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Metronome_Tick(ByRef Dessin As PictureBox)

l'event tick a une signature on ne peut pas la modifier

byref ca n'a rien à faire là non plus

Déclarer la variable Cellule1 comme Public ne me parait pas élégant

enquoi ca serait moins élégant que le reste ?
en private sinon, il n'y a pas de miracle si vous voulez utiliser une variable il faut bien la déclarer quelque part



une fois de plus : lisez un cours !
http://plasserre.developpez.com/cours/vb-net/

[rv26t]

... Mon objectif actuel (phase 2) est de déplacer "simultanément" plusieurs picturebox au moyen d'autant de timers.
...

J'ai tout de même une petite question vis à vis de cette remarque.
Si le nombre de timers est important cela ne risque-t-il pas de poser des problèmes ? (vieux souvenir de vb6, mais bon cela n'est peut-être plus vrai. Je n'ai rien trouvé sur le sujet sur le net.)

[Pol63]

Si le nombre de timers est important cela ne risque-t-il pas de poser des problèmes ?

même si ce la ne pose pas de problème visible, vu qu'on peut le faire avec un seul ca ne sert à rien d'en utiliser plusieurs

[horemheb]

Vos remarques remettent en question ma façon de concevoir un programme orienté objet. J'en suis encore à la méthode du Basic des années 70 c'est à dire un programme principal qui gère tout. Pour moi une Classe est "juste" un moyen de créer des objets avec quelques facilités de manipulation(méthodes, propriétés).
Pour reprendre l'exemple de l'auto. Pour moi la Classe est l'usine qui sert à concevoir un modèle de voiture et à la fabriquer à la demande du client. Le client se sert ensuite du véhicule à l'extérieur de l'usine. J'ai l'impression que vous me proposez d'utiliser le véhicule à l'intérieur de l'usine, ce que je n'arrive pas à concevoir.
D'autre part si l'on gère simultanément plusieurs fenêtres, où se positionne-t-on pour gérer leur fonctionnement ? Si c'est pour le définir à l'intérieur d'une classe, ça revient à créer un module externe sans le dire et les problèmes restent les mêmes.

J'ai de grosses difficultés à assimiler toutes les implications de ce type de programmation (l'âge peut-être?).

Pour revenir à des aspects plus concrets, pourquoi DoEvents() est interdit ?

Concernant les Timers, je vais préciser plus en détail ce que je souhaite réaliser.
Dans une 1ère fenêtre vont se créer, se déplacer puis disparaître des "cellules".
Chacune va laisser une "trace" de son déplacement dans une matrice associée aux pixels d'une 2ème fenêtre.
Les 2 fenêtres se superposent, la 1ère est transparente.
Les cellules ne se déplacent pas à la même vitesse, les déplacements sont plus ou moins aléatoires.

Comment je procède actuellement (une seule cellule):
Je déplace une PictureBox dans la fenêtre du dessus, ce qui évite de remettre à jour l'endroit où elle se situait précédemment. Parallèlement j'utilise un Pen pour effectuer la trace dans la 2ème fenêtre.
J'associe ses déplacements aux Ticks d'un timer. J'en suis là.

Pour gérer plusieurs cellules (10 maxi) j'ai imaginé la technique suivante :
chaque timer aura un Interval différent, donc au travers du Sender du timer il est possible de savoir à quel timer le Tick correspond. d'autre part lorsque l'on instancie plusieurs objets (ici les cellules) elles sont associées à un numéro dans une liste. Il reste ensuite à associer la cellule 1 à l'interval=201 (par exemple), la cellule 2 à l'interval=202, etc, ce qui permettra des déplacements désynchronisés et de résoudre les problèmes de timer liés à la création et disparition des cellules (suis-je clair ???).

Ca revient à réaliser un jeu avec les déplacements d'individus, véhicules ou autres, devant gérer leur environnement (terrain, adversaires, agressions). Ce projet n'a aucun impératif professionnel, il me sert à essayer de comprendre ce type de programmation, pour satisfaire ma curiosité.

Accessoirement il me permet (étant enseignant) de comprendre les difficultés que l'on rencontre pour comprendre un concept nouveau et, par rebond, comment le faire comprendre.

J'espère ne pas vous avoir soûlé avec ma prose.

[horemheb]

oui donc vous écrivez sans avoir compris le cours que vous avez lu

J’avoue sans honte que je ne comprends pas tout ce que je lis, je programme sans avoir assimilé les 1142 pages du cours de P Lasserre. Je maîtrise moyennement la programmation « classique » et j’ai quelques notions sur la Programmation Orientée Objet. C’est pour cela que je fais des essais qui me permettent de mieux comprendre.

Pour avancer j’ai sorti la déclaration de Cellule1 du Sub main() pour qu’il soit accessible depuis Sub Metronome_Tick. Ce qui donne le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
Module Principal
    Private Cellule1 As New PictureBox  'création d'une picturebox
    WithEvents Metronome As New System.Windows.Forms.Timer()    'création du Timer Metronome
 
    Sub main()
        Dim Fenetre As New Form1        'création d'une fenêtre 
        Dim Temps As DateTime
 
        'initialisation cellule 1
        Fenetre.Controls.Add(Cellule1)
        With Cellule1
            .Location = New System.Drawing.Point(20, 50)
            .Size = New System.Drawing.Size(20, 20)
            .TabIndex = 0
            .Image = My.Resources.Cellule_Est
        End With
 
        'affichage initial
        Fenetre.Show()
        Cellule1.Refresh()
        System.Threading.Thread.Sleep(500) 'juste pour visualiser le début
 
        Metronome.Interval = 100    'réglage métronome
        Metronome.Start()           'départ métronome
 
        'pour passer le temps en attendant les Ticks
        Temps = DateTime.Now
        Do While DateTime.Now < Temps.AddSeconds(10)
        Loop
    End Sub
 
    Private Sub Metronome_Tick(ByVal sender As Object, ByVal e As System.EventArgs) Handles Metronome.Tick
        Cellule1.Left += 1
        Cellule1.Refresh()
    End Sub
End Module

Un test en pas à pas révèle que le code boucle sur le Do While … Loop sans être interrompu par l’évènement Metronome.Tick.
Avec une boucle For To Next et une procédure Deplace pour remplacer Metronome_Tick ça fonctionne correctement. Ce qui me fait penser que ça vient de la gestion des Ticks, peut-être liée à ce qui suit que je n'ai pas compris.

bref dans votre module
private _pct as picturebox
...
là vous avez _pct et vous pouvez le déplacer
par contre il faut penser à mettre quelque chose dans _pct sinon ca va planter

_pct De quoi s'agit-il ?

[Pol63]

J’avoue sans honte que je ne comprends pas tout ce que je lis, je programme sans avoir assimilé les 1142 pages du cours de P Lasserre.

^^

Je maîtrise moyennement la programmation « classique » et j’ai quelques notions sur la Programmation Orientée Objet. C’est pour cela que je fais des essais qui me permettent de mieux comprendre.

c'est le principe en effet

Un test en pas à pas révèle que le code boucle sur le Do While … Loop sans être interrompu par l’évènement Metronome.Tick.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Do While DateTime.Now < Temps.AddSeconds(10)
Loop

Alors déjà c'est interdit d'écrire ca, une boucle dans ce genre bouffe 100% des ressources processeur (ou pas loin) pendant 10 secondes
après il y a une notion de thread là dedans, un thread c'est un peu la petite ligne jaune qui avance en pas à pas, un thread ne peut donc être qu'à un endroit à la fois
votre appli démarre sur le thread dit "principal", tous les évènements sont mis sur une pile, puis traités chacun leur tour, vous ne sortez pas de la sub donc le thread ne peut pas dépiler les évènements
sur une appli classique vous auriez un message "ne répond pas" de windows

_pct De quoi s'agit-il ?

bien que j'avais bien votre problème en tête ce n'était pas le cas pour le code
_pct c'est votre cellule1, d'ailleurs c'est écrit ce que c'est :

private _pct as picturebox

donc encore quelques efforts et ca devrait aller
par contre recommencez l'appli et faire un projet de type windows forms qui démarre sur une form
partir sur un sub main n'a aucun sens et ca vous pourrit la vie
quand vous aurez compris le reste vous saurez comment vous débrouiller depuis le sub main, mais là il vous bloque

[horemheb]

Bravo Pol63, vous m'avez mis sur la bonne voie.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

System.Threading.Thread.Sleep(2000)

par exemple, bloque totalement le processus
alors que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

        Do While DateTime.Now < Temps.AddSeconds(10)

accapare totalement le processus. La nuance est subtile mais aussi de taille. Je pensais que les évènements étaient malgré tout gérés et interrompaient la boucle. Ce que vous venez d'infirmer. Il fallait donc réintroduire la gestion des évènements et j'ai repensé à DoEvents() qui joue ce rôle.
ce qui donne pour la boucle :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
        'pour passer le temps en attendant les Ticks
        Temps = DateTime.Now
        Do While DateTime.Now < Temps.AddSeconds(10)
            Application.DoEvents()
        Loop

et ça marche , ma cellule se déplace de nouveau, au rythme des Ticks.

par contre recommencez l'appli et faire un projet de type windows forms qui démarre sur une form
partir sur un sub main n'a aucun sens et ca vous pourrit la vie
quand vous aurez compris le reste vous saurez comment vous débrouiller depuis le sub main, mais là il vous bloque

Il faut croire que j'aime me pourrir la vie car je vais continuer avec mon Sub main() qui rend certes les choses plus délicates mais permet en même temps de mieux comprendre comment les éléments sont gérés. J'ai du temps et je suis très patient. Je vais pouvoir maintenant envisager de créer une classe Cellules comme je l'avais signalé plus tôt.
Merci et à bientôt pour d'autres questions.

[Pol63]

DoEvents()

ca fait parti des instruction interdites aussi ...

vous avez le don pour trouver tout ce qu'il ne faut pas faire ^^

[ebastien]

Bonsoir,
Je me permets de m''immiscer dans votre conversation pour simplement pour faire une petite remarque :

Il faut croire que j'aime me pourrir la vie car je vais continuer avec mon Sub main() qui rend certes les choses plus délicates mais permet en même temps de mieux comprendre comment les éléments sont gérés

ca fait parti des instruction interdites aussi ...

Est-ce qu'à persister dans cette voie, vous n'allez pas chercher des moyens de contournement à des problèmes que vous n'auriez pas en projet Windows Form (Simplement en ajoutant un Application.Run(LaForme) )? Je comprends votre envie de mieux comprendre comment les choses sont gérés mais à mon sens, pour résoudre vos problèmes, vous risquez d'écrire du code inutile voire pas très propre. Par exemple, gérer des controls fenêtrés en dehors de leur fenêtre propriétaire n'est pas logique et certains pourraient même dire que c'est une hérésie au sens objet du terme : Une forme est une classe et qui dit classe dit encapsulation. Donc, le Sub Main ne devrait pas "savoir" ce qui se passe sur la forme ... En plus, ça vous éviterait d'avoir à "passer le temps en attendant les Ticks"
Et puis, rien ne vous empêche au niveau de la forme de créer dynamiquement vos controls comme vous le faites dans le Sub Main (Je pense avoir compris que vous vouliez garder la main et ne pas laisser le boulot au designer pour comprendre le fonctionnement ).
Bon, maintenant, comme dirait l'autre, je dis ça mais je dis rien
Bon code !
eb.

[horemheb]

il faut donc une classe pièce, …, une ou plusieurs instances de capteur température, et une ou plusieurs instances de radiateur.
la classe capteur par contre elle implémente tout ce qu'il faut pour dialoguer avec l'usb, sur un autre thread que le principal tant qu'à faire

Le dire c’est bien, le faire quand on n’a aucune pratique c’est nettement plus difficile. Je conçois à peu près ce que ça signifie, mais, quant à sa mise en
œuvre… Je bloque sur beaucoup de détails qui peuvent paraître anodins, à la fois sur l’architecture du projet et sur des points de code.

Je suis en train d'essayer de restructurer mon projet dans ce sens. Je vais mettre une autre discussion sur le forum concernant les Constructeurs et l’utilisation de New pour créer une instance d’objet.

Reprenons la problématique du DoEvents.
Un évèment tel que un Timer_Tick doit interrompre l’exécution du code en cours. Or il n’a aucun effet sur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
'pour passer le temps en attendant les Ticks
        Temps = DateTime.Now
        Do While DateTime.Now < Temps.AddSeconds(10)
        Loop

Vous m’expliquez que

après il y a une notion de thread là dedans, un thread c'est un peu la petite ligne jaune qui avance en pas à pas, un thread ne peut donc être qu'à un endroit à la fois
votre appli démarre sur le thread dit "principal", tous les évènements sont mis sur une pile, puis traités chacun leur tour, vous ne sortez pas de la sub donc le thread ne peut pas dépiler les évènements

S’il y a un long processus de traitement dans la sub, comment fait-on alors pour l’interrompre ? Qu’en est-il pour une suite de sub imbriquées ? Quand les évènements peuvent-ils s’exécuter ?
Vous dites aussi

doevents interrompt l'exécution du code actuel pour dépiler les évènements

Je pensais que le principe d’un évènement est d’interrompre le processus en cours, quel qu’il soit, pour exécuter le code associé à l’évènement.
Je m'y perds

[Pol63]

le temps d'exécution de la plupart des instructions est très cours (en nanosecondes)
quand vous êtes dans le sub main et que vous appelez une sub, cette sub est executée puis le sub main contenu, il n'y a donc bien qu'une exécution à la fois

un évènement n'interrompt rien, quand vous cliquez sur un bouton l'event click est mis sur la pile, et quand votre programme n'exécute plus rien les évènements sont dépilés
c'est pareil pour timer.tick, ca n'interrompt rien
ca serait très dangeureux si un evenement interrompait l'exécution du code
un évènement sert juste à lier du code à quelque chose qui se passe, que ca soit graphique ou non (arrivée de données sur le réseau par exemple)

après avec le sub main ca embrouille, normalement sur une appli windows forms il y a un application.run(unform) quelque part, ce .run fait que la fenetre ne se ferme pas quand rien ne s'exécute

l'event paint est un évènement qui vient de windows pour rafraichir l'interface (dessin), il fonctionne comme les autres

aussi si vous avez un traitement long, l'interface ne se rafraichit pas et ca mène au "ne répond pas"

doevents mets en pause la sub sur la ligne du doevents, traite tous les évènements à traiter puis reprend sur la ligne d'après

s'il y a un long processus il n'y a pas lieu de l'interrompre, mais il faut le déplacer sur un autre thread
le code qu'on met sur le thread principal ne doit donc pas être long (moins de 200ms par exemple), tout ce qui peut etre long devrait être déporté (lecture d'une base de données etc...)

si on démarre un nouveau thread c'est comme on avait 2 lignes de pas à pas qui avancent en même temps
par contre l'interface ne peut pas être manipulée depuis les autres threads
il est possible d'avoir des évènements sur d'autres threads, depuis des choses qui fonctionnent sur d'autres threads


en résumé il ne faut pas partir avec des à priori mais avec des connaissances, vous n'avez pas pu lire qu'un évènement interrompait l'exécution pour être traité, donc vous l'avez imaginé
il ne faut rien imaginer, microsoft a fait une documentation claire (une fois qu'on a compris comment elle est organisée ^^) qui explique le fonctionnement de tout ...

[DonQuiche]

Reprenons la problématique du DoEvents.
Un évèment tel que un Timer_Tick doit interrompre l’exécution du code en cours.

Non. Une application Windows maintient une file d'attente des messages. Ces messages peuvent être un clic sur la fenêtre, un événement de timer, etcétéra. A la racine de l'application on trouve donc une boucle while (dans Application.Run) qui attend les nouveaux messages et les traite les uns après les autres en levant les événements Timer.Tick ou Button.Click appropriés. Tout le code UI est exécuté depuis cette boucle while.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
boucle
{
   S'il y a des messages
   {
      Message message = plus ancien message.
      si message est un click sur un bouton alors 
      {
          Button bouton = bouton cliqué.
          Pour chaque délégué abonné à bouton.Click
          {
              appeler ce délégué.
          }
      }  
      sinon si message est un événement de timer alors
      {
             ....
      }
   }
   Sinon attendre le prochain message.
}

Autrement dit, si le traitement que tu as présenté est fait en réaction à un Button.Click, alors tant que ce traitement ne sera pas terminé les nouveaux messages ne seront pas traités, y compris ceux du timer. Appeler DoEvents sert justement à traiter les messages en attente avant de continuer. DoEvents est lui-même une boucle while, une "pompe à messages" (message pump) comme celle illustrée ci-dessus.

S’il y a un long processus de traitement dans la sub, comment fait-on alors pour l’interrompre ? Qu’en est-il pour une suite de sub imbriquées ? Quand les évènements peuvent-ils s’exécuter ?

Soit on appelle DoEvents à certains moments, soit on exécute le traitement depuis un thread séparé.

Je pensais que le principe d’un évènement est d’interrompre le processus en cours, quel qu’il soit, pour exécuter le code associé à l’évènement. Je m'y perds

Un événement n'est qu'une liste de délégués. Appeler un événement, c'est comme faire un foreach(var action in Button.Click) action(). Les délégués sont appelés séquentiellement les uns après les autres.

[horemheb]

Pol63 vous affirmez

en résumé il ne faut pas partir avec des à priori mais avec des connaissances, vous n'avez pas pu lire qu'un évènement interrompait l'exécution pour être traité, donc vous l'avez imaginé
il ne faut rien imaginer, Microsoft a fait une documentation claire (une fois qu'on a compris comment elle est organisée ^^) qui explique le fonctionnement de tout ...

Pour commenter votre propos je vous transmets quelques extraits de ce que l’on trouve comme commentaires sur les évènements, Microsoft inclus.

« Supposons, par exemple, que votre application exécute une tâche de tri séparément de l'application principale. Si un utilisateur annule le tri, votre application peut envoyer un événement d'annulation demandant au processus de tri de s'interrompre. »
« Un gestionnaire d'événements est une méthode liée à un événement. Lorsque l'événement est déclenché, le code qu'il contient est exécuté. »
Source Mdsn
« Quand le programme fonctionne, quand l'utilisateur du logiciel clique sur le bouton1, le code situé entre Private Sub Button1Click et End Sub est effectué. »
« Ainsi quand l'utilisateur clique sur le bouton, la procédure Maroutine est exécutée. »
« Cette procédure contient le code qui doit être exécuté lorsque l'utilisateur clique sur le bouton. »
Source Cours VB.Net - P Lasserre
« Si l’évènement se produit, Visual Basic exécutera la procédure correspondante »
Source Visual Basic 6.0 Etape par étape - Mickael Halvorson
« Ici, le but est de créer des événements qui vont être propres à votre application. C'est-à-dire déclencher une action dans votre application lorsque quelque chose se produit et informer les objets abonnés à cet événement. »
Source A la découverte des évènements en .Net - F Cantenot, O Delmotte
« l'application se met à l'écoute des évènements qui se produisent sur le formulaire (clics, déplacements de souris, ...) et fait exécuter ceux que le formulaire gère. »
« On peut associer autant de gestionnaires que l'on veut à un évènement. Ils seront tous exécutés lorsque l'évènement auquel ils sont associes sera déclenché. »
Source Apprentissage du langage VB.Net – S Tahé

Nulle part il n’est clairement signalé, comme vous le dites, que

un évènement n'interrompt rien, quand vous cliquez sur un bouton l'event click est mis sur la pile, et quand votre programme n'exécute plus rien les évènements sont dépilés, c'est pareil pour timer.tick, ça n'interrompt rien

De plus de nombreux exemples dans le fonctionnement d’un ordinateur font croire qu’il est possible d’interrompre un processus. On peut quand on le souhaite interrompre un téléchargement, une copie de dossier, mettre en pause une musique, etc.
Vous comprendrez mieux les difficultés que je rencontre pour réaliser correctement mon projet.
Merci à DonQuiche pour avoir complété le propos de Pol63
Bonne journée à tous ceux qui me lisent

[Pol63]

Nulle part il n’est clairement signalé, comme vous le dites

Nulle part il n'est écrit l'inverse, à savoir que le code de l'event est exécuté automatiquement
il ne faut se fier qu'aux phrases et au vocabulaire, chaque mot a une signification claire
processus = .exe qui tourne
un processus peut contenir plusieurs threads
etc...

« Supposons, par exemple, que votre application exécute une tâche de tri séparément de l'application principale. Si un utilisateur annule le tri, votre application peut envoyer un événement d'annulation demandant au processus de tri de s'interrompre. »

"séparément de l'application principale" veut dire un autre exe
déjà on sort du contexte

Cette procédure contient le code qui doit être exécuté lorsque l'utilisateur clique sur le bouton

il n'est pas précisé quand non plus ^^
d'ailleurs le code d'une sub liée à un event est souvent exécutée juste après la levée de l'évènement .net
quand tu fais un while loop et que tu clics sur un bouton, c'est windows qui détecte le clic sur un bouton, .net n'est pas encore au courant
quand le while s'arrête l'application se met à lire les messages de windows, il voit un clic à telle coordonnées et c'est la qu'il transforme ca en évènement (OnClick qui RaiseEvent Click(me, new mouseeventargs(...)))
mais ca c'est parce que l'écoute des messages windows est faite sur le thread principal, là ou ton while s'exécute
si ton while s'exécute sur un autre thread les évènements des autres threads ne sont pas délayés

On peut associer autant de gestionnaires que l'on veut à un évènement. Ils seront tous exécutés lorsque l'évènement auquel ils sont associes sera déclenché

je précise, tous chacun leur tour

De plus de nombreux exemples dans le fonctionnement d’un ordinateur font croire qu’il est possible d’interrompre un processus.

une action, dans certain cas oui, interrompre un processus c'est en faisant "fin de tâche" dans le gestionnaire des tâches
l'interruption de certaines choses se font grace au multithreading
pour interrompre un téléchargement on ferme la connexion tcp/ip depuis un autre thread ...
la lecture d'une musique c'est un thread qui toutes les x millisecondes envoie un bout de musique à windows, là aussi c'est le thread qui est mis en pause