Fonction IsOpen est-elle bien adaptée ?

Version imprimable

Voir 40 message(s) de cette discussion en une page

Bonjour,

Ma feuille de route :
Vérifier si un fichier TEXTE.txt et/ou un fichier ABC.exe ne sont pas utilisé ou en service.

La fonction IsOpen est appelé en boucle chaque fois que ABC.exe fini son travail. Le temps d'une boucle peut aller d'une demi seconde à plusieurs heures. Le test de l'exe et de txt n'ai pas simultanée.

La routine que j'ai écrit ci-dessous fonctionne mais retourne souvent l'erreur fichier TEXTE.txt déjà ouvert. Pour éviter (phase test) ce problème j'ai mis Catch Exception avec aucune action.

Code:

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
37
38
39
40
41
42
43
44
45
46
47
48
49
 
Public Sub FinModReso()
 
        'Test si le fichier TEXTE.txt et ABC.exe sont toujours ouvert. Si oui attendre. 
        Call IsOpen(Disk + "TEXTE.txt")
        Thread.Sleep(100)
 
        ' Lit le fichier "TEXTE.txt" créé par ABC.exe 
        Dim monStreamReader2 As StreamReader
        monStreamReader2 = New StreamReader(Disk + "TEXTE.txt")
 
       LecturemonStreamReader2 = monStreamReader2.ReadLine() '+ vbNewLine
 
End sub
 
Public Function IsOpen(ByVal sFile As String) As Boolean
        Message = ""
        sFile = Disk + "TEXTE.txt"
        Dim thisFileInUse As Boolean = False
        Dim p() As Process
 
3000:   'test si sFile est ouvert
        If System.IO.File.Exists(sFile) Then
 
            Try
                Using f As New IO.FileStream(sFile, FileMode.Open, FileAccess.ReadWrite, FileShare.None)
                    If FileMode.Open = True Then
                        thisFileInUse = True
                    Else thisFileInUse = False
                    End If
                End Using
            Catch ex As Exception
                'La suite entre '' n'est pas à uiliser car génère un arrêt du process pour problème long puisque erreur de lecture TEXTE.txt déjà ouvert
                'MessageBox.Show(ex.Message, "Description de l'erreur" & vbNewLine &
                '  "ex.Message: " & ex.Message & vbNewLine &
                '  "ex.StackTrace: " & ex.StackTrace)
            End Try
        End If
 
        'Recherche l'état du thread (ici un .exe) en cours d'execution si p.count > 0
        p = Process.GetProcessesByName("ABC")
 
        If thisFileInUse = True Or p.Count > 0 Then
            thisFileInUse = False
            GoTo 3000
        End If
        Return thisFileInUse
 
    End Function

Il est claire que cette routine a un problème, mais je ne vois pas comment écrire une boucle d'attente de non utilisation simultanée d'un exe et d'un texte ! Le goto n'est pas l'essentiel pour résoudre le problème, mais bon si on peut le remplacer.

Avec async et delegate ?

Si vous avez une idée je suis preneur.

Merci d'avance

10/01/2022, 10h54
Phil Rob
Bonjour,

J'aimerais en savoir davantage, sans vouloir faire l'indiscret, sur les tâches que tu attends de ton programme. En fait, je ne comprends pas ce que tu cherches ...

Cela fait quelque temps que tu cherches une solution en rapport avec l'OpenFiledialog et avec le FolderBrowserDialog, et tu ne sembles pas trouver l'usage de ces composants qui te satisfasse pleinement.

Puis, et je suppose qu'il s'agit du même programme, il te faut savoir quand un programme a terminé son job avec un ficher TXT. Cela ne me paraît pas clair, sans doute n'ai-je pas suivi assez assidument l'intégralité de tes questions ...

Dans ton dernier message, je comprends que :
1. Le programme ABC.EXE crée le fichier Text.TXT
2. Le programme ABC.EXE lance la fonction IsOpen pour savoir quand le job de création est terminé
3. Le programme ABC.EXE attends la réponse de IsOpen, tout le temps nécessaire, sans rien faire d'autre (quelques secondes à plusieurs heures ? )
S'il en est bien ainsi, et que cela ne te convienne pas vraiment, comment voudrais-tu que cela soit ?

Je ne comprends pas quand il est nécessaire de se donner tant de difficultés pour écrire un fichier TXT et pour s'assurer qu'il existe.

Tu évoques la programmation asynchrone dans ton message. Serait-ce la fonction IsOpen qui devrait être exécutée sur un autre thread de sorte que les autres tâches de ABC.EXE ne doivent pas attendre ? Dans ce cas, que voudrais-tu qu'il se passe quand la fonction IsOpen se termine, quand elle "sait" que le travail sur le fichier TXT est terminé : doit-elle placer une valeur dans une variable que tu consulterais toutes les 5 secondes (à l'aide d'un Timer, par exemple), doit-elle placer un message "TXT terminé" dans un TextBox réservé à cet effet, .... ?

Je ne te promets pas de solution mais je réfléchirai volontiers à ton problème si je le comprends ....

@+, peut-être ...

:D
10/01/2022, 22h28
excalybur

Bonsoir Phil Rob,

J'ai dû mal m'expliquer. Désolé j'essaie de détailler davantage :

L'idée est la suivante, je développe une plateforme de problèmes d'échecs. Cette plateforme sert à plein de chose comme lire une database ou écrire dessus, mais aussi pour résoudre (créer, corriger ...) les problèmes d'échecs par l'utilisation d'un programme autonome à utiliser en mode CMD c'est le fameux programme autonome ABC.exe.

Au démarrage au travers d'un thread ce programme ABC est nourri par des datas sous un format ad'hoc que j'appelle INPUT.txt, ensuite il fonctionne et au bout d'un certain temps (une fraction de secondes à plusieurs heures) restitue dans TEXT.txt la solution et/ou les erreurs d'entrées. Nota: L'écriture au format TEXT.txt en sortie est imposé par ABC.exe.
Par la suite ma plateforme ré-ouvre TEXT.txt pour charger les datas et les convertir en mode texte et graphique visible sur la plateforme

Chaque problème analysé un par un ne pose pas de problème et mon système fonctionne parfaitement.

Là ou cela se complique, c'est lorsque je lance une boucle 1 à 100 pour résoudre 100 problèmes à la file. Il faut éviter l'emballement du process et l'affichage du message d'erreur "fichier Text.txt déjà ouvert !" Sachant que je ne peut ouvrir qu'un seul ABC.exe à la fois et qu'il faut pendant qu'il s’exécute que le fichier TEXT.txt soit bien fermé puisqu'il va en avoir besoin pour écrire dessus !

Puis par la suite l'on ré-ouvre TEXT.txt pour convertir les datas dans ce cas il faut que ABC.exe attende la fermeture de Text.txt avant de démarrer.

Donc les threads.sleep ne sont pas la solution puisque chaque résolution dure un temps variable! Une boucle de test et d'attente d'état IsOpen se justifie donc.
La routine actuelle fonctionne et de temps en temps sans explication apparente retourne un message "fichier déjà ouvert" et plante

Je pense que IsOPen n'est pas bien au point, il y a probablement des dualités que je n'ai pas vu. Pas simple je l'avoue.

Après réflexion je me demande si la méthode choisie est la bonne? Je propose une autre approche si ça ne marche pas :

Indexer les fichiers de sorties !?

Mon idée:

Décharger TEXT.txt chaque fois dans un fichier indexé TEXT1.txt, puis TEXT2.txt.. et détruire TEXT.txt

Pour cela il faut détecter la création TEXT.txt (surveillance de la modification de l'heure du fichier ?).

Du coup => plus de problème de surveillance de l'état ouvert/fermé de Text.txt !

Le programme analyse le contenu de chaque TEXT(n) et continu jusqu'au dernier. Pendant ce temps ABC.exe analyse chaque problème jusqu'au dernier

Il faut bien sur arriver à faire fonctionner l'ensemble en mode asynchrone sachant que le programme doit attendre chaque retour de ABC.exe pour continuer la conversion.

Cela devrait contourner IsOpen. Le revers de la médaille : Tout ré-écrire. Pas simple non plus.

Accessoirement je vois que le système à vite une limite : Quid avec 10000 problèmes? Le DD va chauffer:D (c'est la même chose avec mon application IsOpen) Il faudra peut être utiliser un disque virtuel mais ça c'est un autre chalenge pour plus tard.

Merci et à vous lire.
10/01/2022, 23h18
Phil Rob

Bonsoir,
Je viens de lire ta réponse en vitesse, je verrai cela attentivement delain.
Mais je me pose déjà cette question :
Pourquoi ne pas appeler ABC.Exe avec la commande SHELL ou avec Process.Start et utiliser l'option d'attendre la fin travail ?
Par ailleurs, dans ABC.Exe, si je comprends bien, il n'y a pas d'inconvénient à attendre que TEXT.TXT soit disponible.
Je tâcherai de faire un projet de tests dans ce sens.
Bonne nuit... :D
10/01/2022, 23h47
Phil Rob

Question subsidiaire pour assurer ma compréhension.

Peux-tu me confirmer :
Un programme X (celui qui accède aux données) utilise le fichier TEXT.TXT en lecture et en écriture.
Un programme ABC.EXE utilise aussi le fichier TEXT.TXT en lecture et en écriture.
X et ABC ne peuvent accéder au même fichier que chacun à son tour.

Est-il possible que ce soit X.EXE qui appelle ABC.EXE ou bien celui-ci doit-il obligatoirement être lancé "manuellement" en CMD ?

Je crois avoir plein de solutions ... mais il vaut mieux que j'aille dormir.

A demain...
11/01/2022, 12h04
popo

Le processus que tu décris semble être bien complexe.
Cette complexité est, selon moi, induite par le fait que ton fichier Text.txt est utilisé par plusieurs processus.
Ce qui du coup t'oblige à mettre en attente l'un des processus pendant que l'autre utilise le fichier.
Avec un tel système, il risque d'y avoir un moment où tu vas avoir un accès concurrent non géré.

A mon avis, chaque process devrait être autonome et surtout travailler sur des fichiers différents.
Ton idée de compteur peux fonctionner mais sa gestion risque également d'être complexe car il faut gérer l'existant et le tout venant.

Je te propose un processus similaire mais moins complexe.
L'idée est que ton process ABC recherche des fichiers à l'extension ABC et avec un nom unique (généré à partir d'un ID unique provenant de ta base ou via Guid.NewGuid().ToString()).
Ex : 38C1FE17-4B6D-4A9F-BACE-B3E069EE3D44.abc
Ex : 4B873804-8ADF-4035-817A-CDFD615666BA.abc

ABC traite chaque fichier "*.abc" et écrit le résultat dans un fichier avec une extension ABCR (R pour Résultat).
Ex : 38C1FE17-4B6D-4A9F-BACE-B3E069EE3D44.abc => 38C1FE17-4B6D-4A9F-BACE-B3E069EE3D44.abcr
Ex : 4B873804-8ADF-4035-817A-CDFD615666BA.abc => 4B873804-8ADF-4035-817A-CDFD615666BA.abcr

Ton deuxième processus va se concentrer sur les fichier ABCR pour transformer le résultat en mode texte et graphique.
11/01/2022, 13h26
Phil Rob

1 pièce(s) jointe(s)
Bonjour,

A défaut d'avoir déjà tes réponses à mes questions, j'ai supposé que :
1. Un programme X (celui qui accède aux données) utilise le fichier TEXT.TXT en lecture et en écriture.
2. Un programme ABC.EXE utilise aussi le fichier TEXT.TXT en lecture et en écriture.
3. X et ABC ne peuvent accéder au même fichier que chacun à son tour.
Partant de là, j'ai réalisé le projet « FichierEntre2Appli » de tests qui contient 2 applications (pour les besoins de ce test, leurs codes sont presque identiques) :
1. X_AppMaitre (est l’application qui fournit les données du fichier TEXT.TXT)
2. ABC_AppSecondaire (est l’application qui utilise, modifie et complète les données du fichier TEXT.TXT)
X_AppMaitre peut créer TEXT.TXT quand il n’existe pas et le reste du temps, le lire et lui ajouter des données.
ABC_AppSecondaire ne peut rien faire si TEXT.TXT n’existe pas. Quand il existe, elle peut le lire et lui ajouter des données.

L’une comme l’autre de ces applications ne peut accéder au fichier que s’il est libéré par l’autre application. Quand l’application a besoin du fichier, elle lance une procédure SurveillanceFichier() qui attendra la disponibilité du fichier dans bloquer tout le programme. Quand le fichier est disponible pour une tâche prédéterminée (lire ou écrire), le travail est fait dans une procédure ExploiteFichier() qui rend le fichier à nouveau disponible quand elle a terminé son job.

Pour tester ce projet, il faut modifier Dim NomEtCheminDuFichier As String = "D:\Tmp\FichierEntre2Appli\" & "TEXT.TXT" au début du Form de chacune des 2 applications, selon ce qu’il en est sur ton PC, puis les compiler.

Il faut ensuite se rendre dans les dossiers Debug (ou Release) pour lancer le programme EXE.
On a alors les 2 applications exploitant alternativement le même fichier TEXT.TXT (avec l’illusion de la simultanéité).

Vois cette vidéo : https://www.dropbox.com/s/irsq856b0d...Appli.mp4?dl=0

Voici le fichier du projet pour tes expérimentations : Pièce jointe 611627. Son code est bien documenté.

J'espère que ceci t'apportera de bonnes idées ... :D
11/01/2022, 18h17
Phil Rob

2 pièce(s) jointe(s)

Un petit complément ... j'avais rien d'autre à faire ... :D

Cette version permet à une application de vérifier si l'autre est active ou non : Pièce jointe 611644.

@+ ... :D

Pièce jointe 611645

Bonsoir,

Merci beaucoup pour vos réponses et le temps que vous avez passé. Excusez-moi pour la réponse tardive. Sur la route toute la journée aujourd'hui.... Heureusement que c'est pas tous les jours ainsi!

J'ai lu vos remarques et propositions pertinentes !

Je confirme la question de Phil Rob :

Un programme X (celui qui accède aux données) utilise le fichier TEXT.TXT en lecture et en écriture.
Un programme ABC.EXE utilise aussi le fichier TEXT.TXT en lecture et en écriture.
X et ABC ne peuvent accéder au même fichier que chacun à son tour.

Pour le shell j'utilise la variante VB.net :
Code:

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 Public Sub Task1() Try 'démarre process Using myProcess2 As New Process 'Dim ProcessProperties As New Process myProcess2.StartInfo.FileName = Disk + "\ABC.exe" myProcess2.StartInfo.Arguments = " -maxmem 4096000" myProcess2.StartInfo.Arguments = Disk + "\input.txt" 'cache l'affichage des fenêtre cmd en mode multi solutions If ValidAutoSolution = True Then myProcess2.StartInfo.WindowStyle = ProcessWindowStyle.Hidden Else myProcess2.StartInfo.WindowStyle = ProcessWindowStyle.Normal End If 'démarre process exe myProcess2.Start() Thread.Sleep(50) 'Dimensionne la fenêtre cmd SetWindowPos(myProcess2.MainWindowHandle, IntPtr.Zero, 1201, 0, 720, 1000, 0) End Using Catch ex As Exception End Try End Sub
J'ai apprécié la séparation des taches proposé par Phil Rob avec X_AppMaitre peut créer TEXT.TXT et ABC_AppSecondaire. La vidéo est pédagogique. Merci beaucoup. Comment fait-tu une vidéo d'écran ?
Concrètement ce que tu propose nécessite une ré-écriture d'une partie du code. Je vais faire des tests dans ce sens. Il faut toutefois que je garde à l'esprit : l'arrêt d'urgence de ABC.exe depuis le programme X ! En effet si je veut arrêter ABC dans une recherche interminable il me faut un bouton stop CMD qui existe dans mon application que pour le mode résolution d'un problème. La fenêtre CMD n’apparaissant pas pour gagner du temps, il ne sera pas possible d'arrêter ABC.exe avec CTRL-C....

L'analyse et l'idée de popo de séparer les noms des fichiers et donc les taches doit être faisable. Je vais faire un test. En effet ABC.exe ne fourni que le format TEXTE.txt en sortie. C'est un exe que je ne sait pas modifier. J'ai bien le code source C / C++ mais je ne sait pas le compiler ni même le comprendre (un jour peut être)... Donc je l'utilise ainsi pour l'instant. Chaque chose en son temps.

Mon idée :

ABC.exe donne une réponse TEXT.txt
Renommer avec X : TEXT en TEXTR
Convertir en graphique sur X
Temporisation 500ms
me.refresh()
Deuxième tour pour ABC.exe...
et ainsi de suite.

Allez je vais faire des tests et je vous tiens au courant.

Merci encore pour vos contributions.

A+

Bonsoir,

Pour faire vite ...

Pour la video, j'utilise la version gratuite (et donc très limitée) de FlashBack Express Recoder et de FlashBack Express Player. Cela permet d'enregistrer une zone prédéfinie, de la visualiser et d'enregistrer la video au format mp4. Bref, c'est largement suffisant. J'utilise aussi parfois Free Screen Video Recorder en version gratuite. La qualité est moindre qu'avec Flash Back.

Pour ce qui est de l'arrêt d'urgence, tu as ce qu'il faut dans ma dernière version. Là où je vérifie qu'une application est active, il suffit de placer un KILL. Par exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Private Sub BoutonKILL_Click(sender As Object, e As EventArgs) Handles BoutonKILL.Click Dim P As System.Diagnostics.Process Try For Each P In System.Diagnostics.Process.GetProcesses If P.ProcessName.ToUpper Like "ABC*" Then ' MessageBox.Show("ABC*.EXE est actif") P.Kill ' =============> stoppe net le Process en question Exit Sub End If Next Catch End Try ' MessageBox.Show("ABC*.EXE n'est pas actif") End Sub
Ta procédure Task qui te sert au lancement de ABC.EXE me paraît trop complexe. Je la réviserai demain. L'application X_AppMaitre aura 2 boutons : un pour lancer ABC_AppSecondaire et un pour le stopper. J'avis compris que tu lançais ABC.Exe en ligne de commande. Sinon, j'aurais déjà programmé son lancement dans X_AppMaitre.

A demain ... :D

Merci Phil Rob

La fonction kill je la connais bien et elle marche bien sur mon programme donc ne t'embête pas pour cela sauf si tu as du temps. :D

Attention le programme ABC.exe fonctionne en parallèle avec X qui ne s'arrête pas sauf boucle d'attente.

La fonction démarrage de ABC.exe :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
Public Sub StartResolution()
 
        ButtonEndSolving.Visible = True
         Thread.Sleep(150)
 
        If tTask1 IsNot Nothing Then tTask1 = Nothing
        tTask1 = New Thread(AddressOf Task1) With {
        .IsBackground = True}
        tTask1.Start()
 
       'test en boucle pour pouvoir arrêter ABC.exe en urgence
        Do
            ButtonEndSolving.Select()
            Thread.Sleep(150)
            StopSolvingTool.Select()
            Thread.Sleep(150)
        Loop Until tTask1.IsAlive = True
 
    End Sub

1 pièce(s) jointe(s)

Bonjour Excalybur,

Je ne comprends pas trop bien ta procédure de démarrage de ABC, notamment, je ne vois l'utilité de placer des Sleep ..., ça me saoule ... :?

Si tu veux que ABC démarre en // avec X.EXE, il suffit de le lancer à partir de la procédure Load du Form principal de X.EXE, avec un simple Process.Start().

Par ailleurs, tu veux pouvoir arrêter ABC en "urgence". Comme dit hier, le Process.Kill() fait bien l'affaire. Il n'y a pas lieu de gérer ces actions sur ABC sur des threads différents. Les opérations Process sont (peut-être toutes) des opérations asynchrones. Elles rendent "la main" au programme appelant immédiatement. Elles ne sont pas bloquantes.
Enfin, si tu prévois un bouton d'arrêt d'urgence, je suppose que tu as aussi besoin d'un bouton pour pouvoir relancer ABC, sans arrêter ni redémarrer X.EXE.

Je pense donc te donner les outils utiles avec mes 2 boutons placés sur X. Le bouton d'arrêt d'urgence peut aussi être placé sur ABC. Mais là, un bouton de redémarrage est inutile ...

Si tu crains que ABC soit lancé plusieurs fois en //, il suffit d'utiliser le code de mon bouton BIsActif et de ne pas n'exécuter le Process.Start si ABC est déjà actif.

Je te renvoie le projet complet pour tes tests : Pièce jointe 611696.

Voici les codes ajoutés dans X_AppMaitre :
Code:

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 ' Les déclarations et procédures suivantes pour démarrer et arrêter l'application secondaire ' à partir de l'application en exécution. Si nécessaire, la ligne du Process.Start peut être ' écrite dans la procédure Load du Form. ' Le chemin suivant peut être simplement CurDir() si ABC.EXE est dans le même dossier que X.EXE. Dim CheminDuFichierABC As String = "D:\Tmp\FichierEntre2Appli\ABC_AppSecondaire\bin\Debug" Dim NomDuFichierABC As String = "ABC_AppSecondaire.EXE" Private Sub BRun_ABC_Click(sender As Object, e As EventArgs) Handles BRun_ABC.Click System.Diagnostics.Process.Start(CheminDuFichierABC & "\" & NomDuFichierABC) End Sub Private Sub BKill_ABC_Click(sender As Object, e As EventArgs) Handles BKill_ABC.Click Dim P As System.Diagnostics.Process Try For Each P In System.Diagnostics.Process.GetProcesses If P.ProcessName = NomDuFichierABC.Substring(0, NomDuFichierABC.IndexOf(".")) Then P.Kill() ' Exit Sub ' Ne pas placer cet Exit peut être utile, notamment lors des tests pour killer tous les Process ABC "oubliés" End If Next Catch End Try End Sub
@+ ... :D

12/01/2022, 17h52
excalybur

Bonjour

Merci Phil Rob pour tes outils.

Il est clair que mon code pêche sérieusement. Le pourquoi de Thread sleep => temps d'accès au DD et surtout prévoir de ne pas saturer par des boucles voraces le processeur d'une ancienne tablette de l'utilisateur final à petit budget. J'ai pas ce problème : je me contente de mon i9 9900 dans mon PC de bureau:D

Je vais m'attaquer à une version TEST en intégrant les éléments au fur et à mesure. Mon programme ABC est mal conçu (handles ???) quand on le compare à note.exe. Le premier te supprime la main depuis X, le second te laisse le contrôle....

J'ai revu l'historique du pourquoi j'en suis arrivé là ! Pour faire simple au départ effectivement quand je regarde mes sources j'ai procédé plus ou moins comme tu le décrit. Ceci est parfaitement vérifiable quand je fait le test avec des programmes CMD "bien pensé" comme note.exe par exemple. Kill n'aura pas de bug et le bouton d'arrêt sera sélectionnable.

Le programme ABC est lui par contre mal conçu ! Une fois lancé il t'empêche d'avoir la main sur les boutons de X, donc difficile de l'arrêter! Un problème avec les handles que je ne sait pas gérer. C'est la raison des thread pour pouvoir garder la main depuis X quand ABC.exe fonctionne. J'ai mis ce problème en sommeil depuis plusieurs mois car je devais finir d'autres choses. J'avais même fait un petit programme test avec delegate et je lancais quatre programmes ABC.exe à la fois ! Je pouvais les arrêter au choix etc... J'ai perdu le source final. Je le retrouverais. Mais la transposition a posé problème avec la lecture de StreamReader TEXT.txt.... La boucle est bouclé !

Allez au boulot !

Au fait tu as utilisé qu'elle version de NET ? J'utilise 4.8 et VS 2022. La raison de 4.8 : Correction de gros bugs dans les glyphes des richtextbox.

A+

Merci encore pour tes codes.
12/01/2022, 18h19
Phil Rob

Ma version Visual Studio ?

J'ai toujours été réticent à installer la dernière version proposée. Elle n'apporte le plus souvent que du changement d'interface et peu de fonctionnalités qui ME soient utiles.

Cependant, depuis ma retraite, j'interviens sur divers forums d'entraide en VB.Net et pour pouvoir fournir des copies d'écran et des vidéos pertinentes, j'ai bien dû me "charger" de quelques versions

Je dispose actuellement des versions 2013, 2015, 2017 et 2019, certaines en interface française et d'autres en interface espagnole.
Le projet de test que je t'ai envoyé a été produit en VisualStudio 2017 ES. J'aurais dû choisir une version FR avant de faire la video ... :(

Je ne vois pas d'urgence à installer la version 2021 ou 2022. Je n'ai actuellement aucune demande qui justifierait de fatiguer davantage mon vieux PC, toujours sous Windows 8.1.

Bon travail pour la suite ... :D

Bonsoir ,

Une très bonne nouvelle j'ai réussi à faire fonctionner les deux programmes en symbiose. Grand merci à Phil Rob grâce à son aide perspicace ! :bravo::chin:

Je me suis inspiré de ses routines et j'en ai écrit une qui marche avec notepad.exe de windows ou les CMD 'hors norme' comme mon programme ABC.exe !
Pour l'utiliser avec un autre programme il suffit de remplacer notepad.exe, etc.

Dans le code j'ai laissé des lignes de codes en commentaires suivant l'usage que vous voulez en faire. Dans mon cas tout n'est pas nécessaire.

Ouvrir un nouveau projet Form, placez y un textbox et deux boutons 'run' et 'kill'

Voici le code :

Code:

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
 
Option Explicit On
 
Imports System.IO
Imports System.Runtime.InteropServices
Imports System.Threading
 
Public Class Form1
 
    Dim FALire As System.IO.StreamReader
    Dim CheminDuFichierABC As String = "D:\windows"
    Dim NomDuFichierABC As String = "notepad.exe"
    Dim CheminDuFichierTEXT As String = "D:\TEST"
    Dim NomDuFichierTEXT As String = "TEXTE.txt"
    Dim AttendreFichierDisponible As System.Threading.Thread = Nothing
    Delegate Sub IsFichierDisponible(Resultat As Byte)
 
    Dim FichierDisponible As Byte    ' 0 = rien à faire     :    1 = lecture    :    2 = écriture
    Dim Permission As Byte   ' 0 = rien à faire     :    1 = lecture    :    2 = écriture 
 
    Private Sub BRun_ABC_Click(sender As Object, e As EventArgs) Handles Brun_ABC.Click
 
        ''Nettoie le fichier qui recevra le résultat ou cré le fichier s'il n'existe pas et éventuellement le répertoire
        ''cette routine bug => "fichier déjà ouvert !"
        Using StreamToWriteOut As StreamWriter = File.CreateText(CheminDuFichierTEXT & "\" & NomDuFichierTEXT)
            StreamToWriteOut.Write("Ceci est un test !") 'Enregistre en écrasant le fichier en place 
            'Await StreamToWriteOut.WriteAsync("Ceci est un test !") 'à utiliser si on travail en asynchrone
        End Using
 
        'début du process
        Using myProcess2 As New Process
 
            myProcess2.StartInfo.FileName = CheminDuFichierABC & "\" & NomDuFichierABC
            myProcess2.Start() 'start process exe
            Permission = 1
            'attendre la fin du process
            ActiverSurveillanceFichier()
 
            'Attention l'instruction suivante fonctionne mais bloque toute action sur le bouton kill ! A ne pas utiliser ! : ' myProcess2.WaitForExit() 
 
        End Using
 
        'faire le test pour vérifier que TEXTE.txt est bien fermé
        '.... OK le programme semble bien fonctionner sans ce test !
        'A vérifier dans le futur montage avec accès multiples et rapides
 
        ' Lit la Solution dans le fichier "TEXTE.txt" 
        Dim monStreamReader2 As StreamReader
        monStreamReader2 = New StreamReader(CheminDuFichierTEXT & "\" & NomDuFichierTEXT)
        Dim SolutionBrut = ""
        TextBox1.Text = ""
        SolutionBrut += monStreamReader2.ReadToEnd()
 
        'affiche la solution 
        TextBox1.Text = SolutionBrut
        monStreamReader2.Close()
 
    End Sub
 
    Private Sub ActiverSurveillanceFichier()
        AttendreFichierDisponible = New System.Threading.Thread(AddressOf SurveillanceFichier)
        AttendreFichierDisponible.Start()
 
        Try
            If AttendreFichierDisponible.IsAlive Then
                AttendreFichierDisponible.Join()
            End If
        Catch
        End Try
    End Sub
 
    Private Sub SurveillanceFichier()
        While True
            If permission = 0 Then
                Exit While
            Else
                If System.IO.File.Exists(CheminDuFichierABC & "\" & NomDuFichierABC) Then
                    Try
                        If Permission = 1 Then   ' ouvrir en lecture
                            FALire = New System.IO.StreamReader(CheminDuFichierABC & "\" & NomDuFichierABC)
                            ''          FichierDisponible = 1  ' permettre la lecture des données
                            'Else  ' si Permission = 2, ouvrir en écriture (rien à faire si permission 0)
                            '    FAEcrire = New System.IO.StreamWriter(NomEtCheminDuFichier, True)
                            '    ''           FichierDisponible = 2  ' permettre l'écriture des données
                        End If
                        Exit While
                    Catch
                        ' on continue la boucle des essais d'ouverture
                    End Try
                Else
                    Try
                        If permission = 2 Then  ' si Permission = 2, créer le fichier pour écriture
                            ' FAEcrire = New System.IO.StreamWriter(NomEtCheminDuFichier)
                            ''          FichierDisponible = 2  ' permettre l'écriture des données pour la première fois
                        Else
                            permission = 0  ' tentative de lecture d'un fichier non existant
                        End If
                        Exit While
                    Catch
                        ' on continue la boucle des essais d'ouverture
                    End Try
                End If
            End If
        End While
        FichierDisponible = permission
        Me.BeginInvoke(New IsFichierDisponible(AddressOf ExploiteFichier), FichierDisponible)
    End Sub
 
    Private Sub ExploiteFichier(FichierDisponible As Byte)
        Me.Refresh()
        Select Case FichierDisponible
            Case 0   'PERMISSION 0 : le fichier n'est pas ouvert   
            Case 1  'PERMISSION 1 : le fichier est ouvert en lecture CAR IL EXISTAIT
                ' Toutes les opérations de lecture des données sont permises 
                ' Ici, lecture et affichage dans la ListBox
                'LBContenuFichier.Items.Clear()
                'Do Until FALire.Peek = -1
                '    LBContenuFichier.Items.Add(FALire.ReadLine())
                'Loop
                FALire.Close()
              '  FALire.Dispose()
            Case 2  'PERMISSION 2 : le fichier est ouvert en écriture
                ' Toutes les opérations d'écriture de données sont permises
                ' Ici, ajout de contenu de la TextBox dans le fichier
                'FAEcrire.WriteLine("Ajout par X : " & TBAjout.Text & " à " & Now())
                'FAEcrire.Close()
                'FAEcrire.Dispose()
        End Select
 
        ' Eventuelement placer une tempo de quelques secondes pour permettre le lancement manuel de l'application ABC
        '---------------- Le mieux serait probablement de lancer un Process.Start() de l'application ABC 
        '---------------- après s'être assuré qu'elle n'est pas déjà active par la recherche de son Process.Name
 
        '    System.Threading.Thread.Sleep(1000)  ' 1 seconde
 
        Permission = 0
        ' Lancer ActiverSurveillanceFichier() quand on a besoin du fichier (voir boutons Blire et BEcrire)
    End Sub
 
    Private Sub BKill_ABC_Click(sender As Object, e As EventArgs) Handles BKill_ABC.Click
        Dim P As System.Diagnostics.Process
        Dim SolutionBrut = ""
 
        Try
            For Each P In System.Diagnostics.Process.GetProcesses
                If P.ProcessName = NomDuFichierABC.Substring(0, NomDuFichierABC.IndexOf(".")) Then
                    P.Kill()
                    TextBox1.Text = ""
                End If
            Next
        Catch
        End Try
 
    End Sub
 
End Class

J'espère que cela rendra bien service pour d'autres. Il y avait longtemps que je cherchais la bonne méthode.

Encore merci :D

13/01/2022, 22h42
excalybur
Hélas en allant un peu plus loin je me rend compte que le programme n'attends pas la fin de ABC.exe si on lui demande de modifier la taille de la fenêtre CMD après start process!!!

Si ABC est long il va automatiquement y avoir un message d'erreur lorsque le programme va tenter d'ouvrir le fichier TEXTE.txt déjà ouvert.

Sur l'exemple vu dans mon dernier message : Ajouter deux lignes pour redimentionner la taille de la fenêtre CMD de ABC.exe après myprocess2.start() :
Code:

1 2 Thread.Sleep(100) SetWindowPos(myProcess2.MainWindowHandle, IntPtr.Zero, 1201, 0, 720, 1000, 0)
Vous aurez immanquablement la réponse fichier texte.txt déjà ouvert lorsque le programme arrive à la ligne 49 du précédent exemple
Code:

1 2 monStreamReader2 = New StreamReader(CheminDuFichierTEXT & "\" & NomDuFichierTEXT)
Ca veut dire quoi ? ActiverSurveillance n'attends plus ?

La je cale !

Une idée ?
13/01/2022, 23h21
Phil Rob

Bonsoir,
Je suis ici sur smartphone et je n'ai pas accès à tous mes codes source mais de mémoire, je crois qu'il y a une inversion de code dans la procédure ActiverSurveillanceFichier. La disposition que j'avais choisie devait empêcher le lancement redondant du process.
Par ailleurs, si je comprends bien ton dernier message, tu veux modifier le programme qui est en cours d exécution : cela me semble impossible.
Il s'agit d'un programme compilé qui ne peut être modifié par un autre programme. Pour changer la taille de sa fenêtre, il faut le faire à l'écran avec la souris, comme on peut le faire avec presque toutes les fenêtres ous Windows.
... :)

2 pièce(s) jointe(s)

Bonjour

Pour répondre à ton observation on peut parfaitement changer la taille d'un exe avec le code suivant remplacer ABC.exe par notepad.exe disponible dans windows. Il faut pas oublier le <DllImport("user32.dll")> . J'ai corrigé cette partie qui marche bien sur mon programme en développement. Il y a surement un bug dans le précédent exemple.
Voici la modification du code de myProcess2:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 Using myProcess2 As New Process
 
            myProcess2.StartInfo.FileName = CheminDuFichierABC & "\" & NomDuFichierABC
            myProcess2.Start() 'start process exe
 
            'modifier dimension et position du cmd
            Thread.Sleep(100)
            SetWindowPos(myProcess2.MainWindowHandle, IntPtr.Zero, 1201, 0, 720, 800, 0)
            'attendre la fin du process
            ActiverSurveillanceFichier() 'Nota: Lorsque notepad est lancé cette routine continu jusqu'à end de ce sub or qu'elle doit attendre la fin de notepad ou l'action sur le bouton kill !
 
            ' MessageBox.Show("pywin64.EXE n'est pas actif")
            'Attention l'instruction suivante fonctionne mais bloque toute action sur le bouton kill ! A ne pas utiliser ! : ' myProcess2.WaitForExit() 
        End Using

Sans modification :

Pièce jointe 611845

Avec modification :

Pièce jointe 611846

2/ Poue le reste j'ai rajouté dans le sub Suveillance Fichier le code suivant :

Code:

1
2
3
4
5
6
 
'pour surveiller si notepad est en service
  While True
            Dim localByName As Process() = Process.GetProcessesByName("notepad")
            If localByName Is "" Then Permission = 1 : Exit While
        End While

Dans ce cas kill ne fonctionne plus et si l'on ferme manuellement notepad on ne peut pas reprendre la main ni utiliser kill. La boucle est sans fin. Pourquoi?

Donc on est pas loin de la solution mais je ne comprends pas avec le thread Surveillance pourquoi il ne réponds plus. Faut-il un système de thread à désynchroniser ?

Le code complet :

Code:

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
 
Option Explicit On
 
Imports System.IO
Imports System.Runtime.InteropServices
Imports System.Threading
 
Public Class Form1
    <DllImport("user32.dll")>
    Shared Function SetWindowPos(ByVal hWnd As IntPtr, ByVal hWndInsertAfter As IntPtr, ByVal X As Integer, ByVal Y As Integer, ByVal cx As Integer, ByVal cy As Integer, ByVal uFlags As Integer) As Boolean
    End Function
 
    Dim FALire As System.IO.StreamReader
    Dim CheminDuFichierABC As String = "D:\windows"
    Dim NomDuFichierABC As String = "notepad.exe"
    Dim CheminDuFichierTEXT As String = "D:\TEST"
    Dim NomDuFichierTEXT As String = "TEXTE.txt"
    Dim AttendreFichierDisponible As System.Threading.Thread = Nothing
    Delegate Sub IsFichierDisponible(Resultat As Byte)
 
    Dim FichierDisponible As Byte    ' 0 = rien à faire     :    1 = lecture    :    2 = écriture
    Dim Permission As Byte   ' 0 = rien à faire     :    1 = lecture    :    2 = écriture 
 
    Private Sub BRun_ABC_Click(sender As Object, e As EventArgs) Handles BRun_ABC.Click
 
        ''Nettoie le fichier qui recevra le résultat ou cré le fichier s'il n'existe pas et éventuellement le répertoire
           Using StreamToWriteOut As StreamWriter = File.CreateText(CheminDuFichierTEXT & "\" & NomDuFichierTEXT)
            StreamToWriteOut.Write("Ceci est un test !") 'Enregistre en écrasant le fichier en place 
            'Await StreamToWriteOut.WriteAsync("Ceci est un test !") 'à utiliser si on travail en asynchrone
        End Using
 
        'début du process
        Using myProcess2 As New Process
 
            myProcess2.StartInfo.FileName = CheminDuFichierABC & "\" & NomDuFichierABC
             myProcess2.Start() 'start process exe
 
            'modifier dimension et position du cmd
            Thread.Sleep(100)
            SetWindowPos(myProcess2.MainWindowHandle, IntPtr.Zero, 1201, 0, 720, 800, 0)
            'attendre la fin du process
            ActiverSurveillanceFichier() 'Nota: Lorsque notepad est lancé cette routine continu jusqu'à end de ce sub or qu'elle doit attendre la fin de notepad ou l'action sur le bouton kill !
 
        End Using
 
        'ici vérifier si texte.txt est bien fermé avant de l'ouvrir pour charger les infos
 
        ' Lit la Solution dans le fichier "TEXTE.txt" 
        Dim monStreamReader2 As StreamReader
        monStreamReader2 = New StreamReader(CheminDuFichierTEXT & "\" & NomDuFichierTEXT)
        Dim SolutionBrut = ""
        TextBox1.Text = ""
        SolutionBrut += monStreamReader2.ReadToEnd()
 
        'affiche la solution 
        TextBox1.Text = SolutionBrut
        monStreamReader2.Close()
 
    End Sub
 
    Private Sub ActiverSurveillanceFichier()
        AttendreFichierDisponible = New System.Threading.Thread(AddressOf SurveillanceFichier)
        AttendreFichierDisponible.Start()
 
        Try
            If AttendreFichierDisponible.IsAlive Then
                AttendreFichierDisponible.Join()
            End If
        Catch
        End Try
    End Sub
 
    Private Sub SurveillanceFichier()
 
        'boucle de test
        While True
            Dim localByName As Process() = Process.GetProcessesByName("notepad")
            If localByName Is "" Then Permission = 1 : Exit While
        End While
 
 
        While True
            If Permission = 0 Then
                Exit While
            Else
                If System.IO.File.Exists(CheminDuFichierABC & "\" & NomDuFichierABC) Then
                    Try
                        If Permission = 1 Then   ' ouvrir en lecture
                            FALire = New System.IO.StreamReader(CheminDuFichierABC & "\" & NomDuFichierABC)
                            ''          FichierDisponible = 1  ' permettre la lecture des données
                            'Else  ' si Permission = 2, ouvrir en écriture (rien à faire si permission 0)
                            '    FAEcrire = New System.IO.StreamWriter(NomEtCheminDuFichier, True)
                            '    ''           FichierDisponible = 2  ' permettre l'écriture des données
                        End If
                        Exit While
                    Catch
                        ' on continue la boucle des essais d'ouverture
                    End Try
                Else
                    Try
                        If Permission = 2 Then  ' si Permission = 2, créer le fichier pour écriture
                            ' FAEcrire = New System.IO.StreamWriter(NomEtCheminDuFichier)
                            ''          FichierDisponible = 2  ' permettre l'écriture des données pour la première fois
                        Else
                            Permission = 0  ' tentative de lecture d'un fichier non existant
                        End If
                        Exit While
                    Catch
                        ' on continue la boucle des essais d'ouverture
                    End Try
                End If
            End If
        End While
        FichierDisponible = Permission
        Me.BeginInvoke(New IsFichierDisponible(AddressOf ExploiteFichier), FichierDisponible)
    End Sub
 
    Private Sub ExploiteFichier(FichierDisponible As Byte)
        Me.Refresh()
        Select Case FichierDisponible
            Case 0   'PERMISSION 0 : le fichier n'est pas ouvert   
            Case 1  'PERMISSION 1 : le fichier est ouvert en lecture CAR IL EXISTAIT
             Case 2  'PERMISSION 2 : le fichier est ouvert en écriture
 
        End Select
 
           Permission = 0
    End Sub
 
    Private Sub BKill_ABC_Click(sender As Object, e As EventArgs) Handles BKill_ABC.Click
        Dim P As System.Diagnostics.Process
        Dim SolutionBrut = ""
 
        Try
            For Each P In System.Diagnostics.Process.GetProcesses
                If P.ProcessName = NomDuFichierABC.Substring(0, NomDuFichierABC.IndexOf(".")) Then
                    P.Kill()
                    TextBox1.Text = ""
                End If
            Next
        Catch
        End Try
 
    End Sub
 
End Class

15/01/2022, 00h19
Phil Rob

Bonsoir,

La façon dont tu as écrit ActiverSurveillanceFichier peut de lancer le même process un nombre de fois quelconque avec chaque fois une nouvelle occupation mémoire (usage de New). Je n'ai rien testé dans ce sens et le résultat me parait douteux.
Par ailleurs, la détection d'un Exe actif ne nécessite pas tant de manoeuvres (vois mon code du bouton IsActif).
Enfin, ta demande initiale concernait le programme ABC.EXE et non le NotePad. Les programmes ABC et X surveille la disponibilité du fichier TEXT.TXT et non d'un Exe.
Bref, je pense que les codes que je t'ai envoyé ne conviennent pas pour l usage que tu veux faire.
Il est facile de vérifier si ABC est déjà actif pour ne pas le lancer une 2ème fois et mes codes permettent de vérifier si la ressource TEXT.TXT est disponible pour eviter les erreurs de partage du fichier.
De ta description du problème, je ne comprends pas l'intérêt de lancer ABC plusieurs fois simultanément. Si cela ne doit pas ce faire, il suffit de ne pas l'activer lorsqu'il l'est deja et il n'y a pas lieu d'activer la surveillance fichier sur le programme secondaire, ABC ou NotePad.
Peut-être dois-tu redéfinir l'énoncé du problème et si ABC est toujours le NotePad, mes codes ne te conviennent pas car tu ne peux programmer "ma" surveillance fichier à l'intérieur du NotePad (sauf peut-être avec ImportDll... , perso je me refuse à utiliser les Dll système depuis DotNet, et j'en ai oublié l'usage).
Par contre, la surveillance du fichier TEXT.TXT devrait permettre de lancer NotePad seulement quand ce fichier est disponible. Dans ce cas, j'en reviens à surveiller la ressource et non l'EXE.
Bonne nuit... :)
15/01/2022, 11h36
Phil Rob

2 pièce(s) jointe(s)

Suite ...

Bonjour,

La nuit porte conseil dit-on ... C'est probablement pourquoi je pensé pourvoir faire rapidement (rapidement car j'ai très peu de temps durant ce week-end) une application de test de partage du fichier TEXT.TXT entre une application X et le NotePad.

Voici donc le projet FichierEntre1AppliEtNotePad : Pièce jointe 611856.

Voici la vidéo de son fonctionnement (excuse pour les 2 dernière secondes hors sujet, pas le temps de refaire) : https://www.dropbox.com/s/aunivrvx2e...tePad.mp4?dl=0

Sauf à ne pas lancer plusieurs fois NotePad avec son fichier TEXT.TXT, la surveillance du fichier est la même que dans le projet précédent. Simplement, ici, le fichier est disponible quand NotePad se ferme. et pour NotePad, le fichier est toujours disponible puisque le NotePad est lancé avec ce fichier en paramètre.
Cette version devrait t'aider davantage si le programme ABC est bien toujours le NotePad. si c'est autre chose encore, je laisse tomber ... :(

Très bon week-end,

:D

Pièce jointe 611857

Voir 40 message(s) de cette discussion en une page