Problem beim Programmneustart mit Instanzkontrolle

[Opa Knack]

Den Bezug zwischen JCL und der Kuh übernehme ich dann mal in meinen Sprachgebrauch...

Wenn ich das richtig verstehe (sorry, Musicman, aber in D2006 ist CharInSet nicht verfügbar, somit konnte ich das nicht ausprobieren), muss ich den Mutex freigeben, bevor ich ihn erzeuge (was ja auch logisch ist). Dann ergibt sich aber aus meiner Sicht das Problem, dass ich den Neustart ja vom Programm aus initiiere, der Mutex also noch besteht, und das dieser erst freigegeben werden kann, wenn das Programm auch beendet ist. Oder sehe ich das falsch?

Ich habe inzwischen ausprobiert, ob ich den Mutex dadurch freigeben kann, dass ich vor Programmende versuche, ihn neu zu erzeugen und bei Vorhandensein über CloseHandle freizugeben, leider jedoch ohne Erfolg.

Hat jemand noch eine andere praktikable Idee?

[Dalai]

Ich mache es so: der/das Mutex wird erst erzeugt, nachdem alle Programmparameter abgearbeitet sind. Die zweite Instanz wird mit einem bestimmten Parameter gestartet und wenn der gefunden wird, schließt die zweite Instanz die erste bereits laufende.

Mal in Code-Form (Auszug aus der .dpr):

Delphi-Quellcode:

begin
    if (ParamCount > 0) then
    begin
        Params:= ParamStr(1);
        if (Params = 'runas') then
        begin
            SendMessage(StrToInt(ParamStr(2)), WM_CLOSE, 0, 0);
        end;
    end;

    hMutex:= CreateMutex(nil, True, PRODUCTNAME + PRODUCTNAME + PRODUCTCOPYRIGHT);
    if GetLastError = ERROR_ALREADY_EXISTS then
    (* Weiterer hierfür nicht relevanter Code *)

    if hMutex <> 0 then
        CloseHandle(hMutex);
end.

Ich glaube, ParamStr(2) war die PID oder so, damit die Message nur an die laufende erste Instanz gesendet wird.

MfG Dalai

[Sir Rufo]

Zitat von Opa Knack:

Wenn ich das richtig verstehe (sorry, Musicman, aber in D2006 ist CharInSet nicht verfügbar, somit konnte ich das nicht ausprobieren), muss ich den Mutex freigeben, bevor ich ihn erzeuge (was ja auch logisch ist).

Das ist richtig

Zitat von Opa Knack:

Dann ergibt sich aber aus meiner Sicht das Problem, dass ich den Neustart ja vom Programm aus initiiere, der Mutex also noch besteht, und das dieser erst freigegeben werden kann, wenn das Programm auch beendet ist. Oder sehe ich das falsch?

Das siehst du richtig, dass du das falsch siehst

Zitat von Opa Knack:

Ich habe inzwischen ausprobiert, ob ich den Mutex dadurch freigeben kann, dass ich vor Programmende versuche, ihn neu zu erzeugen und bei Vorhandensein über CloseHandle freizugeben, leider jedoch ohne Erfolg.

Du hast vom Seil etwas abgeschnitten und festgestellt, dass es immer noch zu kurz ist?

Zitat von Opa Knack:

Hat jemand noch eine andere praktikable Idee?

Ja, gib den Mutex vor dem Aufruf von ShellExecute mit CloseHandle frei.

Dann wird das Handle geschlossen (übersetzt heißt CloseHandle -> SchließeHandle).
Wird der Prozess beendet, dann werden alle noch offenen Handles von diesem Prozess automatisch geschlossen.
Aber in diesem Falle musst du den halt vorher manuell freigeben.

Delphi-Quellcode:

  // Nun ja ... wenn schon dann bitte mit Self
  {form1}Self.Close;
  // Da wir aber die Anwendung schließen wollen, müssen wir das HauptFormular schließen, also besser
  Application.MainForm.Close;

  // wozu das? unnötig!
  // application.ProcessMessages; 

  // Hier jetzt das Handle vom Mutex freigeben
  CloseHandle( MyAppMutexHandle );

  // Nicht das Application.Handle übergeben sondern 0
  ShellExecute({Application.Handle} 0, 'open', Pchar(ParamStr(0)), nil, nil, sw_SHOWNORMAL);

[Sir Rufo]

Hier die versprochene Klasse

Delphi-Quellcode:

unit AppMutex;

interface

type
  TAppMutexStrategy = class abstract
  private
    procedure SetActive( const Value : Boolean );
  protected
    function GetActive : Boolean; virtual; abstract;
    procedure AquireMutex; virtual; abstract;
    procedure ReleaseMutex; virtual; abstract;
  public
    destructor Destroy; override;
  end;

  TAppMutex = class
  private
    class var FStrategy : TAppMutexStrategy;
  private
    class procedure SetActive( const Value : Boolean ); static;
    class function GetActive : Boolean; static;
    class destructor Destroy;
  public
    class property Active : Boolean read GetActive write SetActive;
    class procedure SetStrategy( AStrategy : TAppMutexStrategy );
  end;

  TNamedAppMutexStrategy = class( TAppMutexStrategy )
  private
    FHandle : Cardinal;
    FName :   string;
  protected
    procedure AquireMutex; override;
    procedure ReleaseMutex; override;
    function GetActive : Boolean; override;
    function GetName : string; virtual;
    property Name : string read GetName;
  public
    constructor Create( const AName : string );
  end;

  TLocalAppMutexStrategy = class( TNamedAppMutexStrategy )
  protected
    function GetName : string; override;
  end;

  TGlobalAppMutexStrategy = class( TNamedAppMutexStrategy )
  protected
    function GetName : string; override;
  end;

implementation

uses
  Windows,
  SysUtils;

{ TAppMutex }

class destructor TAppMutex.Destroy;
begin
  FreeAndNil( FStrategy );
end;

class function TAppMutex.GetActive : Boolean;
begin
  Result := FStrategy.GetActive;
end;

class procedure TAppMutex.SetActive( const Value : Boolean );
begin
  FStrategy.SetActive( Value );
end;

class procedure TAppMutex.SetStrategy( AStrategy : TAppMutexStrategy );
begin
  if Assigned( FStrategy )
  then
    FreeAndNil( FStrategy );

  FStrategy := AStrategy;
end;

{ TAppMutexStrategy }

destructor TAppMutexStrategy.Destroy;
begin
  SetActive( False );
  inherited;
end;

procedure TAppMutexStrategy.SetActive( const Value : Boolean );
begin
  if Value = GetActive
  then
    Exit;

  if Value
  then
    AquireMutex
  else
    ReleaseMutex;
end;

{ TNamedAppMutexStrategy }

procedure TNamedAppMutexStrategy.AquireMutex;
var
  LLastError : Cardinal;
begin
  FHandle := CreateMutex( nil, True, PChar( Name ) );

  LLastError := GetLastError;

  if LLastError = ERROR_ALREADY_EXISTS
  then
    begin
      CloseHandle( FHandle );
      FHandle := 0;
    end;
end;

constructor TNamedAppMutexStrategy.Create( const AName : string );
begin
  inherited Create;
  FName := AName;
end;

function TNamedAppMutexStrategy.GetActive : Boolean;
begin
  Result := ( FHandle <> 0 );
end;

function TNamedAppMutexStrategy.GetName : string;
var
  LIdx : Integer;
begin
  Result   := FName;
  for LIdx := 1 to Length( Result ) do
    begin
      if not CharInSet( Result[LIdx], ['0' .. '9', 'A' .. 'Z', 'a' .. 'z', '-'] )
      then
        Result[LIdx] := '_';
    end;
end;

procedure TNamedAppMutexStrategy.ReleaseMutex;
begin
  CloseHandle( FHandle );
  FHandle := 0;
end;

{ TLocalAppMutexStrategy }

function TLocalAppMutexStrategy.GetName : string;
begin
  Result := 'Local\' + inherited;
end;

{ TGlobalAppMutexStrategy }

function TGlobalAppMutexStrategy.GetName : string;
begin
  Result := 'Global\' + inherited;
end;

end.

Im Einsatz so

Delphi-Quellcode:

program MutexTest;

uses
  Forms,
  MainView_Form in 'MainView_Form.pas' {MainView} ,
  AppMutex in 'AppMutex.pas',
  AlertView_Form in 'AlertView_Form.pas' {AlertView};

{$R *.res}

begin
  // Strategie einstellen
  TAppMutex.SetStrategy( TGlobalAppMutexStrategy.Create( '6D274674-150A-490E-B8D0-726C6D556F29' ) );
  // Aktivieren
  TAppMutex.Active := True;

  // Überprüfung
  if not TAppMutex.Active
  then
  begin
    TAlertView.Create( nil ).ShowModal;
    Halt;
  end;

  Application.Initialize;
  Application.MainFormOnTaskbar := True;
  Application.CreateForm( TMainView, MainView );
  Application.Run;

end.

[musicman56]

Hallo,

vielen Dank Sir Rufo, ich werd's mal ausprobieren

[hathor]

Das Problem "OneInstance" hatte ich heute auch und habe es im DPR-File gelöst.
Wenn das zuerst gestartete Programm minimiert ist, wird es angezeigt.
Funktioniert auch unter WIN 8.0.

Delphi-Quellcode:

program TEST1;

uses
  Forms, Windows,
  Unit1 in 'Unit1.pas' {Form1};

{$R *.res}

procedure SwitchToThisWindow(h1: hWnd; x: bool); stdcall; external user32 Name
'SwitchToThisWindow'; {x = false: Size unchanged, x = true: normal size}

var
  PreviousHandle : THandle;
begin
  PreviousHandle := Windows.FindWindow(NIL,'MyProg'); //MyProg = Form1.caption
  if PreviousHandle = 0 then
  begin
    Application.Initialize;
    Application.CreateForm(TForm1, Form1);
    Application.Run;
  end
  else
 begin
    if Windows.IsIconic(PreviousHandle) then
        Windows.ShowWindow(PreviousHandle, SW_RESTORE);
    SwitchToThisWindow(PreviousHandle, TRUE);
    SetForegroundWindow(PreviousHandle);
    SetWindowPos(PreviousHandle,
      HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE or SWP_NOSIZE or SWP_SHOWWINDOW);
 end;
end.

[Opa Knack]

Danke für die hilfreichen Tipps, ich werde mich hineinknien. Übrigens funktioniert es mit

Delphi-Quellcode:

  // Nun ja ... wenn schon dann bitte mit Self
  {form1}Self.Close;
  // Da wir aber die Anwendung schließen wollen, müssen wir das HauptFormular schließen, also besser
  Application.MainForm.Close;

  // wozu das? unnötig!
  // application.ProcessMessages;

  // Hier jetzt das Handle vom Mutex freigeben
  CloseHandle( MyAppMutexHandle );

  // Nicht das Application.Handle übergeben sondern 0
  ShellExecute({Application.Handle} 0, 'open', Pchar(ParamStr(0)), nil, nil, sw_SHOWNORMAL);

nicht. Selbst wenn man MyAppMutexHandle (das logischerweise nicht vorhanden ist) durch den eigentlichen Mutex ersetzt.

[Sir Rufo]

Zitat von Opa Knack:

Danke für die hilfreichen Tipps, ich werde mich hineinknien. Übrigens funktioniert es mit
... nicht. Selbst wenn man MyAppMutexHandle (das logischerweise nicht vorhanden ist) durch den eigentlichen Mutex ersetzt.

Dann machst du irgendwas noch falsch, denn mit dem Freigeben des Mutex-Handle kann dieser Mutex wieder belegt werden.
(getestet)

Ähm, ja logisch ist das nicht bekannt - hätte ich besser schreiben sollen DatAppMutexDingensBumsHandleWatDuDaVerstecktInDerUnitRumliegenHast

Da du folgenden Code in deiner unit hast

Delphi-Quellcode:

if mHandle <> 0 then CloseHandle(mHandle)

gehe ich auch davon aus, dass du weißt wie man ein Handle freigibt und dass man dazu auch das Handle selber braucht