IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

VB.NET Discussion :

Fonction IsOpen est-elle bien adaptée ?


Sujet :

VB.NET

  1. #1
    Membre régulier Avatar de excalybur
    Homme Profil pro
    Chargé d'affaire
    Inscrit en
    novembre 2014
    Messages
    205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Chargé d'affaire
    Secteur : Conseil

    Informations forums :
    Inscription : novembre 2014
    Messages : 205
    Points : 123
    Points
    123
    Par défaut Fonction IsOpen est-elle bien adaptée ?
    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 : 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
    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
    La Connaissance est comme le rire elle est contagieuse en la partageant!

  2. #2
    Membre émérite Avatar de Phil Rob
    Homme Profil pro
    Enseignant retraité
    Inscrit en
    novembre 2013
    Messages
    1 390
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Enseignant retraité

    Informations forums :
    Inscription : novembre 2013
    Messages : 1 390
    Points : 2 500
    Points
    2 500
    Par défaut
    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 ...


  3. #3
    Membre régulier Avatar de excalybur
    Homme Profil pro
    Chargé d'affaire
    Inscrit en
    novembre 2014
    Messages
    205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Chargé d'affaire
    Secteur : Conseil

    Informations forums :
    Inscription : novembre 2014
    Messages : 205
    Points : 123
    Points
    123
    Par défaut
    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 (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.
    La Connaissance est comme le rire elle est contagieuse en la partageant!

  4. #4
    Membre émérite Avatar de Phil Rob
    Homme Profil pro
    Enseignant retraité
    Inscrit en
    novembre 2013
    Messages
    1 390
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Enseignant retraité

    Informations forums :
    Inscription : novembre 2013
    Messages : 1 390
    Points : 2 500
    Points
    2 500
    Par défaut
    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...

  5. #5
    Membre émérite Avatar de Phil Rob
    Homme Profil pro
    Enseignant retraité
    Inscrit en
    novembre 2013
    Messages
    1 390
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Enseignant retraité

    Informations forums :
    Inscription : novembre 2013
    Messages : 1 390
    Points : 2 500
    Points
    2 500
    Par défaut
    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...

  6. #6
    Membre expert
    Avatar de popo
    Homme Profil pro
    Analyste programmeur Delphi / C#
    Inscrit en
    mars 2005
    Messages
    1 922
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Analyste programmeur Delphi / C#
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : mars 2005
    Messages : 1 922
    Points : 3 612
    Points
    3 612
    Par défaut
    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.

  7. #7
    Membre émérite Avatar de Phil Rob
    Homme Profil pro
    Enseignant retraité
    Inscrit en
    novembre 2013
    Messages
    1 390
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Enseignant retraité

    Informations forums :
    Inscription : novembre 2013
    Messages : 1 390
    Points : 2 500
    Points
    2 500
    Par défaut
    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 : FichierEntre2Appli.zip. Son code est bien documenté.

    J'espère que ceci t'apportera de bonnes idées ...

  8. #8
    Membre émérite Avatar de Phil Rob
    Homme Profil pro
    Enseignant retraité
    Inscrit en
    novembre 2013
    Messages
    1 390
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Enseignant retraité

    Informations forums :
    Inscription : novembre 2013
    Messages : 1 390
    Points : 2 500
    Points
    2 500
    Par défaut
    Un petit complément ... j'avais rien d'autre à faire ...

    Cette version permet à une application de vérifier si l'autre est active ou non : FichierEntre2Appli.zip.

    @+ ...

    Nom : Fichier2App.jpg
Affichages : 52
Taille : 84,0 Ko

  9. #9
    Membre régulier Avatar de excalybur
    Homme Profil pro
    Chargé d'affaire
    Inscrit en
    novembre 2014
    Messages
    205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Chargé d'affaire
    Secteur : Conseil

    Informations forums :
    Inscription : novembre 2014
    Messages : 205
    Points : 123
    Points
    123
    Par défaut
    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 : 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
     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+
    La Connaissance est comme le rire elle est contagieuse en la partageant!

  10. #10
    Membre émérite Avatar de Phil Rob
    Homme Profil pro
    Enseignant retraité
    Inscrit en
    novembre 2013
    Messages
    1 390
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Enseignant retraité

    Informations forums :
    Inscription : novembre 2013
    Messages : 1 390
    Points : 2 500
    Points
    2 500
    Par défaut
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 ...

  11. #11
    Membre régulier Avatar de excalybur
    Homme Profil pro
    Chargé d'affaire
    Inscrit en
    novembre 2014
    Messages
    205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Chargé d'affaire
    Secteur : Conseil

    Informations forums :
    Inscription : novembre 2014
    Messages : 205
    Points : 123
    Points
    123
    Par défaut
    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.

    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 : 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
     
    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
    La Connaissance est comme le rire elle est contagieuse en la partageant!

  12. #12
    Membre émérite Avatar de Phil Rob
    Homme Profil pro
    Enseignant retraité
    Inscrit en
    novembre 2013
    Messages
    1 390
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Enseignant retraité

    Informations forums :
    Inscription : novembre 2013
    Messages : 1 390
    Points : 2 500
    Points
    2 500
    Par défaut
    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 : FichierEntre2Appli.zip.

    Voici les codes ajoutés dans X_AppMaitre :

    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
     
        ' 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
    @+ ...

  13. #13
    Membre régulier Avatar de excalybur
    Homme Profil pro
    Chargé d'affaire
    Inscrit en
    novembre 2014
    Messages
    205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Chargé d'affaire
    Secteur : Conseil

    Informations forums :
    Inscription : novembre 2014
    Messages : 205
    Points : 123
    Points
    123
    Par défaut
    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

    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.
    La Connaissance est comme le rire elle est contagieuse en la partageant!

  14. #14
    Membre émérite Avatar de Phil Rob
    Homme Profil pro
    Enseignant retraité
    Inscrit en
    novembre 2013
    Messages
    1 390
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Enseignant retraité

    Informations forums :
    Inscription : novembre 2013
    Messages : 1 390
    Points : 2 500
    Points
    2 500
    Par défaut
    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 ...

  15. #15
    Membre régulier Avatar de excalybur
    Homme Profil pro
    Chargé d'affaire
    Inscrit en
    novembre 2014
    Messages
    205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Chargé d'affaire
    Secteur : Conseil

    Informations forums :
    Inscription : novembre 2014
    Messages : 205
    Points : 123
    Points
    123
    Par défaut
    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 !

    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 : 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
    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
    La Connaissance est comme le rire elle est contagieuse en la partageant!

  16. #16
    Membre régulier Avatar de excalybur
    Homme Profil pro
    Chargé d'affaire
    Inscrit en
    novembre 2014
    Messages
    205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Chargé d'affaire
    Secteur : Conseil

    Informations forums :
    Inscription : novembre 2014
    Messages : 205
    Points : 123
    Points
    123
    Par défaut
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    monStreamReader2 = New StreamReader(CheminDuFichierTEXT & "\" & NomDuFichierTEXT)
    Ca veut dire quoi ? ActiverSurveillance n'attends plus ?

    La je cale !

    Une idée ?
    La Connaissance est comme le rire elle est contagieuse en la partageant!

  17. #17
    Membre émérite Avatar de Phil Rob
    Homme Profil pro
    Enseignant retraité
    Inscrit en
    novembre 2013
    Messages
    1 390
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Enseignant retraité

    Informations forums :
    Inscription : novembre 2013
    Messages : 1 390
    Points : 2 500
    Points
    2 500
    Par défaut
    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.
    ...

  18. #18
    Membre régulier Avatar de excalybur
    Homme Profil pro
    Chargé d'affaire
    Inscrit en
    novembre 2014
    Messages
    205
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Chargé d'affaire
    Secteur : Conseil

    Informations forums :
    Inscription : novembre 2014
    Messages : 205
    Points : 123
    Points
    123
    Par défaut
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 :

    Nom : sans.jpg
Affichages : 22
Taille : 20,7 Ko


    Avec modification :

    Nom : Avec.jpg
Affichages : 22
Taille : 26,2 Ko


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

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : 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
    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
    La Connaissance est comme le rire elle est contagieuse en la partageant!

  19. #19
    Membre émérite Avatar de Phil Rob
    Homme Profil pro
    Enseignant retraité
    Inscrit en
    novembre 2013
    Messages
    1 390
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Enseignant retraité

    Informations forums :
    Inscription : novembre 2013
    Messages : 1 390
    Points : 2 500
    Points
    2 500
    Par défaut
    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...

  20. #20
    Membre émérite Avatar de Phil Rob
    Homme Profil pro
    Enseignant retraité
    Inscrit en
    novembre 2013
    Messages
    1 390
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Enseignant retraité

    Informations forums :
    Inscription : novembre 2013
    Messages : 1 390
    Points : 2 500
    Points
    2 500
    Par défaut
    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 : FichierEntre1AppliEtNotePad.zip.

    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,



    Nom : Entre2.jpg
Affichages : 18
Taille : 151,5 Ko

+ Répondre à la discussion
Cette discussion est résolue.
Page 1 sur 2 12 DernièreDernière

Discussions similaires

  1. JavaDoc : cette classe est elle bien commentée ?
    Par jmnicolas dans le forum Langage
    Réponses: 4
    Dernier message: 04/09/2008, 12h36
  2. La fonction display est-elle fonctionnelle sous ie7
    Par develop' peur ! dans le forum Général JavaScript
    Réponses: 8
    Dernier message: 11/02/2008, 18h42
  3. InterpN est elle bien incomprehensible ?
    Par sayag dans le forum MATLAB
    Réponses: 1
    Dernier message: 29/06/2007, 09h18
  4. Réponses: 3
    Dernier message: 04/03/2007, 10h34
  5. La fonction fgets est-elle compatible Windows/Unix ?
    Par ashurai dans le forum Langage
    Réponses: 1
    Dernier message: 05/04/2006, 18h59

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo