✔ Wie kann ich Nachrichten zwischen 2 Prozessen austauschen?

[henhus]

Hallo alle zusammen!

Ich habe eine MFC-Anwendung in der ich andere exe-Dateien ausführen kann. Ich starte diese exe_Dateien in einem eigenen thread mit der Funktion CreateProcess(); Danch warte ich mit der Funktion WaitForSingleObject() auf des Ende des Prozesses und lese den Exitstatus aus.

Mein Problem ist, dass ich während die exe Datei läuft gerne Signale oder Nachrichten zwischen der MFC-Anwendung und der exe-Datei austauschen würde, auf die ich dann mit einem Funktionsaufruf reagieren kann. Ich habe es mal mit Signalen (signal.h) versucht oder mit SendMessage() und GetMessage() , aber ich komme einfach nicht weiter. Ich muss keine großen Datenmengen austauschen. Ich muss nur auf Nachrichten reagieren.

Vielleicht hat ja jemand ne Idee! Ich wäre echt sehr dankbar für jegliche Hilfe!

 

[pschilling]

Hi,

ich habe mal so was in der Art gemacht.

War bestimmt nicht die eleganteste Lösung, aber sie hat funktioniert.

Und zwar habe ich der anderen exe per Kommandozeile das Handle meines Fensters mitgegeben, welches die Nachrichten empfangen sollte.

MySecond.exe -hwnd 7863482368

Diesen Parameter habe ich dann ausgewertet und wieder in ein HWND gecastet.

In der anderen Applikation habe ich dann PostMessage() verwendet, um der eigentlichen Applikation Nachrichten zu schicken. Die Nachrichten, die ich geschickt habe, waren so definiert:

#define WM_MY_FIRST_MESSAGE WM_USER +1
#define WM_MY_SECOND_MESSAGE WM_USER +2

Auf diese Nachrichten habe ich dann in meiner Fensterklasse, deren Handle ich an die zweite exe übergeben habe, in der WindowProc() Funktion ausgewertet.

Wesentlich komplizierter wurde es, als ich auch Daten mit übergeben wollte, aber das hast du ja nicht vor, richtig?

Viel Erfolg,

Peter

 

[henhus]

Danke Peter für die schnelle Antwort.
Die kommunikation von der exe-Datei zur Fensterklasse funktioniert jetzt.
Wie hast du es realisiert auch von der Fensterklasse an die exe-Datei Nachrichten zu senden? Oder brauchtest du das nicht?
Im Voraus vielen Dank!!

 

[DonCube]

Soweit ich weiß kannst du auch auf eine Pipe zurückgreifen um Nachrichten auszutauschen. Allerdings habe ich das bisher nur mit Unix ausführlich gemacht. Unter Windows gibt es generell zwei Arten von Pipes. Anonymous und Named Pipes. Eine anonymous Pipe erstellt man folgendernaßen:

BOOL CreatePipe(                                    /* TRUE, wenn erfolgreich */
PHANDLE phRead,                                      /* Lesen aus Pipe */
PHANDLE phWrite,                                   /* Schreiben in Pipe */
LPSECURITY_ATTRIBUTES lpsa,                       /* Sicherheitsattribute */
DWORD cbPipe                                        /* Größe (Vorschlag) */
);

//Lesen und schreiben erfolgt einfach mittels der handles über:
ReadFile (...);
WriteFile (...);

Ach ja noch wichtig eine anonymous Pipe ist unidirektional und zeichenorietiert. Hauptsächliuch wird soetwas zur Kommunikation zwischen zwei abhängigen Prozessen genutzt.

So nun zur Named Pipe. Diese ist bidirektional, nachrichtenorientiert und netzwerkfähig. Hier ein paar Routinen für die Named Pipe:

CreateNamedPipe(...);                        /* Erzeugen einer Named Pipe */
ReadFile(...};                              /* Lesen und Schreiben */
WriteFile(...);
PeekNamedPipe(...);                          /* Inhalt überprüfen */
TransactNamedPipe(...);                         /* Transaktionen:
                                                WriteFile()
                                                ReadFile() */
CallNamedPipe(...);                            /* Vollständiger Aufrufsequenz:
                                               Create...()
                                               Write...()
                                               Read...()
                                               Close...() */

Ich hoffe das hilft dir als Anregung. Für genaueres in die Win32 API schauen.

Gruß
DonCube

 

[henhus]

Vielen Dank DonCube,
ich habe auch schon über eine Pipe nachgedacht, aber eine Pipe muss ich abfragen. Was ich brauch ist ein Siganl, das sofort einen Interrupt auslöst! Eine Pipe müsste ichpollen oder?

 

[jokey2]

Hier habe ich ein Beispiel, wie ich es mal gemacht habe.
Da muß man die Pipe pollen, aber Du mußt ja sowieso auf das Ende des Prozesses warten. Du kannst ja das Starten des Prozesses und das Warten darauf mit dem Pollen der Pipe in einen eignene Thread verlagern, damit Dein Programm nicht solange steht.

 

[henhus]

Vielen Dank jokey2,
also aller letzen Ausweg werde ich auf eine pipe zurückgreifen.
Das Problem ist, dass ich die aufrufende exe-Datei nicht selber schreibe. Das Programm sollte so einfach wie möglich funktionieren. Es muss doch möglich sein irgendwie Nachrichten zwischen 2 Prozessen unter Windows auszutauschen. Unter Linux habe ich einfach die Signalbehandlung nach POSIX verwendet. Das geht ohne Probleme. Das muss doch auch unter Windows funktionieren!
Vielleicht hat ja noch jemand eine Idee!
Vielen Dank für die Hilfe!

 

[pschilling]

Hi,

ich geb auch noch mal meinen Senf dazu

Also wenn der Mechanismus aus meinem ersten Posting für dich so funktioniert hat, kannst du aus der aufgerufenen exe deinem Fenster mit der ersten Nachricht ja dein Fensterhandle, welches Nachrichten empfangen soll, mitgeben.

Die Datenübergabe zwischen 2 Prozessen ist aber auch nicht Trivial.

Ich hab e 2 Wege probiert, welche auch beide Funktioniert haben.

Der erste war mittels dem Clipboard.
In deiner exe fütterst du das Clipboard mit deinem Fensterhandle, sendest dann eine Message an dein anderes Fenster, welches dann den Wert aus dem Clipboard ausliest und wieder in ein HWND castet.
Dann kannst du deine Messages ja an dieses Handle schicken.

Der zweite Weg lief über den globalen Speicher.
Schau dir dazu die Methoden
- GlobalAlloc();
- GlobalLock();
- GlobalUnlock();
- GlobalFree();

Aber der Weg übers Clipboard war der einfacherer, aber bestimmt auch nicht der schönste

Viel Erfolg,

Peter