4. Ermitteln ob EXE aktiv ist

Ermitteln ob EXE aktiv ist

  • R

    Das Programm, dass laufen muss:

    // Bei Programmstart
HANDLE kdg_mutex = OpenMutex(MUTEX_ALL_ACCESS, 0, "irgend_eine_ID");

// Bei Programmende...
ReleaseMutex(kdg_mutex);

    Im Programm, dass prüft, ob das andere gerade aktiv ist:

    HANDLE kdg_mutex = OpenMutex(MUTEX_ALL_ACCESS, 0, "irgend_eine_ID")

//Wenn Mutex-Handle 1 ist, ist gerade eine Programminstanz aktiv...
if(kdg_mutex)   {
    // Hier was passieren soll, wenn das Programm läuft...
}

    Ist jetzt aber aus'm Kopf, könnten Fehler drin sein 🙄

    0
  • T

    Ich wrede es ausprobieren.
    Erst einmal Vielen Dank für die Unterstützung.

    mfg
    Traugott

    0
  • A

    Hallo

    dazu gibt es bereits in den Builder-Examples ein Control dazu :
    <BCB_Path>\Examples\Controls\SingleInst

    bis bald
    akari

    0
  • M

    Wenn ich das richtig verstanden habe und die anderen falsch, dann willst du feststellen, ob ein Fremdprozess läuft, der nicht von dir stammt?
    In dem Fall könntest du dir die Prozesse anhand des Dateinamens im System auflisten und schauen, ob der gesuchte dabei ist.

    DWORD GetPidByName(PSTR ProcessName) {
	DWORD PIDs[1024], BytesNeeded, ProcessCount;

	//SetDebugPrivilege();

	if (!EnumProcesses(PIDs,sizeof(PIDs),&BytesNeeded)) {
		return 0;
	}

	ProcessCount = BytesNeeded / sizeof(DWORD);
	BytesNeeded = 0;

	for (UINT i = 0;i<ProcessCount;i++) {
		HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION,false,PIDs[i]);

		if (hProcess != NULL) {
			HMODULE hModule;

			char CurProcessName[MAX_PATH];

			if (EnumProcessModules(hProcess,&hModule,sizeof(hModule),&BytesNeeded) ) {
				if (GetModuleBaseName(hProcess,hModule,CurProcessName, sizeof(CurProcessName) )) {
					if (strcmpi(CurProcessName,ProcessName)==0) {
						CloseHandle (hProcess);
						return PIDs[i];
					}
				}
			}
		}

		CloseHandle(hProcess);
	}
	return 0;
}

    Deklarationen in der psapi.h -> psapi.lib einbinden

    0
  • ?

    Reyx schrieb:

    Das Programm, dass laufen muss:

    // Bei Programmstart
HANDLE kdg_mutex = OpenMutex(MUTEX_ALL_ACCESS, 0, "irgend_eine_ID");

// Bei Programmende...
ReleaseMutex(kdg_mutex);

    Ist jetzt aber aus'm Kopf, könnten Fehler drin sein 🙄

    Wenn ich das so benutze, kommen bei mir folgende Fehler:

    [C++ Warnung] Unit1.cpp(21): W8004 'kdg_mutex' wurde ein Wert zugewiesen, der nie verwendet wird
  [C++ Fehler] Unit1.cpp(25): E2451 Undefiniertes Symbol 'kdg_mutex'

    Ich bin damit nicht so vertraut. Muss ich da noch etwas machen?
    Danke im Voraus

    0
  • ?

    Hat echt keiner 'ne Ahnung? 😞

    0
  • A

    Hallo

    die Fehelrmeldung ist doch klar. Du deklarierst zwar kdg_mutex, aber dort wo den Release aufrufst, ist kdg_mutex nicht bekannt. Vermutlich hast du kdg_mutex lokal in eienr Methode deklariert, aber wei ldu den Release in einer anderen aufrufst, must du kdg_mutex stattdesen als Member der Klasse deklarieren.

    Ist das nicht der Fall und du findest den Fehler selber nicht, dann poste nochmal genau, in welchem Zusammenhang die beiden Codezeilen stehen.

    bis bald
    akari

    0
  • ?

    Also jetzt kommt der Fehler nicht mehr. Allerdings funktionierts auch nicht so:

    //---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
HANDLE kdg_mutex = OpenMutex(MUTEX_ALL_ACCESS, 0, "123");
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{
ReleaseMutex(kdg_mutex);
}
//---------------------------------------------------------------------------

    Programm das überprüft werden soll.

    //---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
HANDLE kdg_mutex = OpenMutex(MUTEX_ALL_ACCESS, 0, "123");
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{

//Wenn Mutex-Handle 1 ist, ist gerade eine Programminstanz aktiv...
if(kdg_mutex)
  {
  ShowMessage("Opened");
  }
}
//---------------------------------------------------------------------------

    Programm das überprüft.

    Das überprüfende Programm gibt nie die Meldung aus (ShowMessage), egal ob das erste Programm geöffnet ist oder nicht.

    0
  • C

    http://www.marquardtnet.info/cecke/quickies.1/1_quicky_19.html

    0
  • ?

    Aber da wird erklärt wie man verhindert das ein Programm 2x geöffnet wird.
    Aber ich will eigentlich wissen wie man "ermittelt ob eine EXE Datei geöffnet ist".

    0
  • C

    Aber da wird erklärt wie man verhindert das ein Programm 2x geöffnet wird.

    Damit wird auch doch irgendwie geklärt, ob ein Programm schon läuft. Ob du dann nun einen weiteren Start verhinderst oder sonstewas machst......

    0
  • ?

    Achso ja Sorry hab ein Problem mit logischem Denken hehe
    Danke

    0
  • ?

    OK jetzt läuft es soweit...
    Allerdings ein Problem.

    Programm1 (Ausgeführtes)
    Programm2 (Überprüfendes)

    1. Erst mache ich Programm1 an, dann Programm2. Programm2 meldet das Programm1 bereits läuft. OK soweit. Wenn ich jetzt Programm1 schließe und Programm2 nochmal überprüfen lasse, wird immer noch gemeldet das Programm1 läuft.

    2. Erst starte ich Programm2 und lasse überprüfen, keine Fehlermeldung. Dann starte ich Programm1 und lasse wieder überprüfen, das Programm meldet dass Programm1 läuft. Wenn ich Programm1 schließe wieder der selbe Fehler von Punkt1.

    Programm1:

    //---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
HANDLE hMutex=OpenMutex(MUTEX_ALL_ACCESS,0,"MeinProgramm");
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{
ReleaseMutex(hMutex);
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate(TObject *Sender)
{
if(!hMutex)
  {
  hMutex=CreateMutex(0,0,"MeinProgramm");
  }
else
  {
  ShowMessage("Das Programm läuft bereits");	
  }
}
//---------------------------------------------------------------------------

    Programm2:

    //---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{
HANDLE hMutex=OpenMutex(MUTEX_ALL_ACCESS,0,"MeinProgramm");
if(!hMutex)
  {
  ReleaseMutex(hMutex);
  }
else
  {
  ShowMessage("Das Programm läuft bereits");
  ReleaseMutex(hMutex);	
  }
}
//---------------------------------------------------------------------------
    0
  • A

    Hallo

    ich kann deinen Quellcode jetzt nicht testen, weil ich keinen Builder habe.
    Aber CreateMutex und ReleaseMutex sollten besser in dem Konstruktor bzw. dem Destruktor des Forms stehen, und HANDLE hMutex sollte ein Member des Forms sein (also im Header des Forms nach private deklarieren).

    bis bald
    akari

    0
  • ?

    Danke akari, kannst du (oder jemand anderes) mir noch sagen was Konstruktor und Destruktor bedeutet? Oder wo ich das finde?

    0
  • D

    Konstuktor:

    __fastcall TForm1::TForm1(TComponent* Owner) 
        : TForm(Owner) 
{ 
} 
//---------------------------------------------------------------------------

    besser ist aber das TForm Event OnCreat.

    Destruktor:
    ist ist das TForm Event OnDestroy
    kannst du im Objektinspektor für TForm doppelt klicken.
    Ok stimmt nicht ganz da der Destruktor danach kommt.
    Den Destruktor würde ich nicht überschreiben!

    0
  • A

    Hallo

    besser ist aber das TForm Event OnCreat.

    Falsch. Genausowenig wie OnDestroy besser als der Destruktor sein soll. Das gegenteil ist der Fall, die Begründung hatten wir schon ein paar mal in verschiedenen Threads dieses Forums.

    Danke akari, kannst du (oder jemand anderes) mir noch sagen was Konstruktor und Destruktor bedeutet? Oder wo ich das finde?

    Lies gleich ein ganzes Tutorial zum Thema OOP, denn du wirst es noch brauchen.

    bis bald
    akari

    0
  • D

    Hi,

    http://www.c-plusplus.net/forum/viewtopic-var-t-is-160149-and-highlight-is-%2Aoncreat%2A.html

    Link von Braustein führt zu einem englischen Forum.
    Die Aussage dort ist mir neu:

    Ok, so let's summarize the most important reason why OnCreate is
    dangerous: because it could execute before your constructor executes
    and before any member objects have been initialized. In C++, it is
    generally mandated that a base class constructor should not be able to
    call the member functions of a derived class. OnCreate violates
    this. OnDestroy does too, but during destruction.

    Meine Frage ist jetzt, wie ich den Destruktor der Form einbaue?
    etwa so:

    Beispiel:

    unit1.h

    private:
__fastcall TForm1::TForm1(TComponent* Owner): TForm(Owner);
 ~Form1();
 TGraphics::TBitmap *hallo;

    unit.cpp

    __fastcall TForm1::TForm1(TComponent* Owner) 
        : TForm(Owner) 
{ 
 hallo=new TGraphics::TBitmap();
} 
//--------------------------------------------------------------------------- 
~Form1()
{
 delete hallo;
}

    wäre das so richtig?

    0
  • J

    Bitte die Faustregel beachten: ein Thema ein Thread, ein Thread ein Thema. Danke!

    0
  • ?

    Geht sowas auch indem man prüft, ob z.B. ABC.EXE in den ausgeführten Prozessen steht? Wenn ja, wie prüft man dies?

    0
Anmelden zum Antworten