Hallo an alle,

ich schreibe mir grad eine Klasse zusammen in der ich laufende Programme "verwalten" will.
Nun hab ich das so aufgebaut das man, wenn man zum Beispiel ein Programm aus der Liste
entfernen will, entweder das Handle oder den Index in der Liste übergibt.

markieren

Delphi-Quellcode:

  function DeleteProgramByHandle(Handle: Longword): Boolean;
  function DeleteProgramByIndex(Index: Integer): Boolean;

Ich hätte das aber lieber mittels Override für den anwendenden Entwickler allgemeiner gestaltet
wie zum Beispiel:

markieren

Delphi-Quellcode:

  function DeleteProgram(Handle: Longword): Boolean; Override;
  function DeleteProgram(Index: Integer): Boolean; Override;

Das ich einfach nur .DeleteProgram aufrufen muss, da aber beide Parameter Ganzzahlen sind denke ich
nicht das das klappt oder?

<Edit>
Vor allem da ich intern sowieso von einer Methode in die andere springe, will sagen:
Wenn ich das Programm anhand des Handles in meiner Objectlist gefunden habe übergebe
ich das mit dem Index an die Funktion DeleteProgramByIndex.
</Edit>

<Edit>
Titel geändert
</Edit>

Danke schonmal für eure Antworten, Michael.

genau so ist es, der Compiler weiß nicht welche Variante aufgerufen werden soll wenn der Aufruf so aussieht
DeleteProgram(50); denn bei 50 ist hier kein Typ angegeben. Desweiteren ist override hier fehl am platz sondern overload muss verwendet werden (override ist zum überschreiben der Vorfahrenmethoden da)

du meinst wahrscheinlich nicht override sondern overload

der Compiler sollte nicht meckern....hm interessant ist es schon....
einfach mal ausprobieren und gucken welche Methode wann aufgerufen wird

Entweder dun nimmst verschiedene Namen für die Prozeduren (kein Überladen), oder du nimmst den Umweg über eine typisierte Konstante, oder gibst dem Compiler an, was du meinst.

z.B.

markieren

Delphi-Quellcode:

Const z50: Integer = 50;
DeleteProgram(z50);

DeleteProgram(Integer(50));

@Tyr: der Compiler meckert ... er ruft nicht einfach so blind was auf

Du meinst overload.
Wenn du einen Handle hast, dann benutze auch THandle.

Die Funktionen auch mit Longword vs Integer sind moeglich. Der Compiler beschwert sich nicht.
Man muss nur aufpassen wie man aufruft. Mit Variablen ist es kein Problem, da der Compiler den Typ feststellen kann.
Bei Konstanten muss man wissen welchen Typ der Compiler appliziert. Ein $1 waere ein Cardinal waehrend eine 1 ein Integer ist.
Lustig wird es bei einem Integer groesser als MaxInt. Der Compiler macht ein Int64 daraus und was dann beim Downcast passiert ist unklar.

Zitat von Robert Marquardt:

Die Funktionen auch mit Longword vs Integer sind moeglich. Der Compiler beschwert sich nicht.
Man muss nur aufpassen wie man aufruft. Mit Variablen ist es kein Problem, da der Compiler den Typ feststellen kann.
Bei Konstanten muss man wissen welchen Typ der Compiler appliziert. Ein $1 waere ein Cardinal waehrend eine 1 ein Integer ist.
Lustig wird es bei einem Integer groesser als MaxInt. Der Compiler macht ein Int64 daraus und was dann beim Downcast passiert ist unklar.

Also also bei D7 & D4 bekomm ich öfters mal beschwerden vom Compiler, wenn ich sowas versuche.

PS: Wenn man LonWord/Cardinal und THandle überlädt, wird der Compiler noch schlimmer,
da ja THandle von LongWord abgeleitet ist -.-''

Hallo !

Danke erstmal für die schnellen und guten Antworten. Ja ich meine overload aber
ich glaube der Tipp mit den Handle und dem Integer könnte klappen!

Wenn ich

markieren

Delphi-Quellcode:

  function deleteprogram(Handle: THandle): Boolean; Overload;
  function deleteprogram(Index: Integer): Boolean; Overload;

nehme sollte das wirklich klappen.

Sobald ich das testen kann sag ich euch bescheid ob das klappt, ich hab grad noch n
anderen Fehler das ich nichts in meine ObjektListe einfügen kann da ich Exceptions
bekomme.


P.S.: Compilieren will er schonmal mit dem Overload

...grad mal ausprobiert...

zusammenfalten · markieren

Delphi-Quellcode:

...
  private
    { Private declarations }
    function DoSomething(AInteger: Integer): String; overload;
    function DoSomething(ALongWord: LongWord):String; overload;
...

...
begin
...
NeAndereZahl:= DoSomething(LongWord(EineZahl)); //word

oder

NeAndereZahl := DoSomething(Integer(EineZahl)); //integer

oder auch

NeAndereZahl := DoSomething(StrToInt(NeZahlAlsString)); //integer


...
end;

so geht es...der Compiler meckert nicht, das einzig wichtige ist der Aufruf
dort muss explizit gesagt werden was es für ein Typ ist (casten)

Ich poste mal kurz n bisschen mehr Code:

zusammenfalten · markieren

Delphi-Quellcode:

unit RunningPrograms;

interface

uses Contnrs, Windows, Messages;

Type
  TProgramInformations = class
    Handle: THandle;
    Caption: String;
  End;

  TRunningPrograms = class
    Constructor Create;
    Constructor Destroy;
    private
      oPrograms: TObjectlist;
      Function getIndexbyHandle(Handle: THandle): Integer;
    Public
      Function ReadToplevelPrograms: Boolean;
      Procedure AddProgram(Handle: THandle; Caption: String);
      Function DeleteProgram(Handle: THandle): Boolean; Overload;
      Function DeleteProgram(Index: Integer): Boolean; Overload;
      // Todo: per Override dem Entwickler nur eine Prozedur mit
      // beiden Parametern abieten
      Function getCaption(Handle: THandle): String; Overload;
      Function getCaption(Index: Integer): String; Overload;

      Function Count: Integer;
  end;

implementation

Constructor TRunningPrograms.Create;
begin
  If Not(Assigned(oPrograms)) then
    oPrograms := TObjectList.Create(True);
  oPrograms.Clear;
end;

Constructor TRunningPrograms.Destroy;
begin
  If Assigned(oPrograms) then
    oPrograms.Free;
  oPrograms := NIL;
end;

Function TRunningPrograms.getIndexbyHandle(Handle: THandle): Integer;
Var
  ndx: Integer;

Begin
  Result := -1;
  If Assigned(oPrograms) then
    for ndx := 0 to oPrograms.Count - 1 do
    begin
      If (oPrograms.Items[ndx] as TProgramInformations).Handle = Handle then
      Begin
        Result := ndx;
        Break;
      End;
    end;
End;

Function TRunningPrograms.ReadToplevelPrograms: Boolean;

  function GetWindows(const hWnd : THandle; LParam: LPARAM): LongBool; stdcall;
  var
    cLen: Longint;
    strCaption: String;

  begin
    Result := True;
    if (IsWindowVisible(hWnd)) and
       ((GetWindowLong(hWnd, GWL_HWndPARENT) = 0) or
       (GetWindowLong(hWnd, GWL_HWndPARENT) = GetDesktopWindow)) and
       (GetWindowLong(hWnd, GWL_EXSTYLE) and WS_EX_TOOLWINDOW = 0) then
    begin
      cLen := SendMessage(hWnd, WM_GETTEXTLENGTH, 0, 0);
      if cLen > 0 then
      begin
        SetLength(strCaption, cLen);
        SendMessage(hWnd, WM_GETTEXT, cLen + 1, Longint(Pchar(strCaption)));
        AddProgram(hWnd, strCaption);
      end;
    end;
    // mit Result = False kann die Callbackfunktion vorzeitig verlassen werden
  end;

Begin
  If Assigned(oPrograms) then
  begin
    EnumWindows(@GetWindows, 1);
    Result := True;
  end else
    Result := False;
End;

Procedure TRunningPrograms.AddProgram(Handle: THandle; Caption: String);
Begin
  If Assigned(oPrograms) then
  begin
    oPrograms.Add(TProgramInformations.Create);
    //(oPrograms.Last AS TProgramInformations).Handle := Handle;
    //(oPrograms.Last AS TProgramInformations).Caption := Caption;
  end;
End;

Function TRunningPrograms.DeleteProgram(Handle: THandle): Boolean;
Var
  ndx: Integer;

Begin
  ndx := getIndexbyHandle(Handle);
  If ndx >= 0 then
  begin
    Result := DeleteProgram(ndx);
  end else
    Result := False;
End;

Function TRunningPrograms.DeleteProgram(Index: Integer): Boolean;
Begin
  If oPrograms.Count - 1 >= Index then
  begin
    oPrograms.Delete(Index);
    Result := True;
  end else
    Result := False;
End;

Function TRunningPrograms.getCaption(Handle: THandle): String;
Begin
  Result := '';
  If Assigned(oPrograms) then
    If getIndexbyHandle(Handle) >= 0 then
      Result := getCaption(getIndexbyHandle(Handle));
End;

Function TRunningPrograms.getCaption(Index: Integer): String;
Begin
  Result := '';
  If Assigned(oPrograms) then
    IF oPrograms.Count - 1 >= Index then
      Result := (oPrograms.Items[Index] AS TProgramInformations).Caption;
End;

function TRunningPrograms.Count: Integer;
begin
  If Assigned(oPrograms) then
    Result := oPrograms.Count else
    Result := 0;
end;

end.

In der Funktion AddProgram bekomme ich eine Exception, wisst Ihr warum? Normalerweise müsste
das doch klappen wenn die Objektliste erzeugt ist oder? Hab schon öfter Objektlisten benutzt
und das hat eigentlich immer geklappt!

Hier mal mein Aufruf:

zusammenfalten · markieren

Delphi-Quellcode:

procedure TfrmMain.Button1Click(Sender: TObject);
Var
  myPrograms: TRunningPrograms;
  ndx: Integer;
  str: String;

begin
  myPrograms := TRunningPrograms.Create;
  If myPrograms.ReadToplevelPrograms then
  begin
    for ndx := 0 to myPrograms.Count - 1 do
    begin
      ListBox1.Items.Add(myPrograms.getCaption(ndx));
    end;
  end;
  myPrograms.Free;
end;

Ist das nicht alles ein wenig krank?
Du willst dem Anwender einerseits einen Gefallen tun, indem Du ihm nur eine Methode zum Löschen anbietest, gleichzeitig ärgerst Du ihn richtig gewaltig, indem Du ihm so eine Typecasting-Falle einbaust. Ich als Anwender traue mir schon zu, mir zwei Methoden zu merken.

Also, mach es richtig:

markieren

Delphi-Quellcode:

DeleteProgramByIndex (aIndex : Integer);
DeleteProgramByHandle(aHandle: THandle);

Das ist viel sauberer und stabiler.

Wenn Du mir eine API mit überladenen Funktionen geben würdest, dann würde ich dich verklagen. Und zwar auf mutwilliges Herbeiführen von haareausraufenden Bugsuchwochenendsessions.