AGB  ·  Datenschutz  ·  Impressum  







Anmelden
Nützliche Links
Registrieren

Prozesse beenden

Ein Thema von Knotti2015 · begonnen am 24. Apr 2005 · letzter Beitrag vom 24. Apr 2005
Antwort Antwort
Knotti2015
(Gast)

n/a Beiträge
 
#1

Prozesse beenden

  Alt 24. Apr 2005, 14:31
Hallo Leutz again,

ich kann mit dem netten Code von Lucki

Delphi-Quellcode:

 uses
  PSAPI, TlHelp32;

function GetProcessName(PID: DWORD; var ProcessName: string): DWORD;
var
  dwReturn : DWORD;
  hProc : Cardinal;
  buffer : array[0..MAX_PATH - 1] of Char;
begin
  dwReturn := 0;
  Zeromemory(@buffer, sizeof(buffer));
  hProc := OpenProcess(PROCESS_QUERY_INFORMATION or PROCESS_VM_READ, FALSE, PID);
  if hProc <> 0 then
  begin
    GetModulebaseName(hProc, 0, buffer, sizeof(buffer));
    ProcessName := (string(buffer));
    CloseHandle(hProc);
  end
  else
    dwReturn := GetLastError;
  result := dwReturn;
end;

type
  TPIDList = array of DWORD;

function GetProcessList(var ProcessList: TPIDList): DWORD;

  function GetOSVersionInfo(var Info: TOSVersionInfo): Boolean;
  begin
    FillChar(Info, SizeOf(TOSVersionInfo), 0);
    Info.dwOSVersionInfoSize := SizeOf(TOSVersionInfo);
    Result := GetVersionEx(TOSVersionInfo(Addr(Info)^));
    if (not Result) then
    begin
      FillChar(Info, SizeOf(TOSVersionInfo), 0);
      Info.dwOSVersionInfoSize := SizeOf(TOSVersionInfo);
      Result := GetVersionEx(TOSVersionInfo(Addr(Info)^));
      if (not Result) then
        Info.dwOSVersionInfoSize := 0;
    end;
  end;

var
  dwReturn : DWORD;
  OS : TOSVersionInfo;
  // EnumProcesses
  PidProcesses : PDWORD;
  PidWork : PDWORD;
  BufferSize : Cardinal;
  Needed : DWORD;
  cntProcesses : Cardinal;
  i : Cardinal;
  // CreateToolhelp32Snapshot
  hProcSnapShot: THandle;
  pe32 : TProcessEntry32;
  j : Cardinal;

begin
  dwReturn := 0;
  // What OS are we running on?
  if GetOSVersionInfo(OS) then
  begin
    if (OS.dwPlatformId = VER_PLATFORM_WIN32_NT) and (OS.dwMajorVersion = 4) then
    // WinNT and higher
    begin
      Needed := 0;
      BufferSize := 1024;
      GetMem(PidProcesses, BufferSize);
      // make sure memory is allocated
      if Assigned(PidProcesses) then
      begin
        try
          // enumerate the processes
          if EnumProcesses(PidProcesses, BufferSize, Needed) then
          begin
            dwReturn := 0;
            cntProcesses := Needed div sizeof(DWORD) - 1;
            PidWork := PidProcesses;
            setlength(ProcessList, cntProcesses);
            // walk the processes
            for i := 0 to cntProcesses - 1 do
            begin
              ProcessList[i] := PidWork^;
              Inc(PidWork);
            end;
          end
          else // EnumProcesses = False
            dwReturn := GetLastError;
        finally
          // clean up no matter what happend
          FreeMem(PidProcesses, BufferSize);
        end;
      end
      else // GetMem = nil
        dwReturn := GetLastError;
    end
    // Win 9x and higher except WinNT
    else
    begin
      // make the snapshot
      hProcSnapShot := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
      if hProcSnapShot <> INVALID_HANDLE_VALUE then
      begin
        pe32.dwSize := sizeof(TProcessEntry32);
        j := 0;
        setlength(ProcessList, j + 1);
        if Process32First(hProcSnapShot, pe32) then
        begin
          // first process
          ProcessList[j] := pe32.th32ProcessID;
          // walk the processes
          while Process32Next(hProcSnapShot, pe32) do
          begin
            Inc(j);
            setlength(ProcessList, j + 1);
            ProcessList[j] := pe32.th32ProcessID;
          end;
        end
        else // Process32First = False
          dwReturn := GetLastError;
        CloseHandle(hProcSnapShot);
      end
      else // hSnapShot = INVALID_HANDLE_VALUE
        dwReturn := GetLastError;
    end;
  end;
  result := dwReturn;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  retValue : DWORD;
  ProcessList : TPIDList;
  i : Integer;
  ProcessName : string;
  PID : DWORD;
resourcestring
  rsUnknown = 'unbekannt';
begin
  // VCL causes last error to be set, even nothing has already happend :-/
  SetLastError(0);
  retValue := GetProcessList(ProcessList);
  if retValue = 0 then
  begin
    for i := 0 to length(ProcessList) - 1 do
    begin
      PID := ProcessList[i];
      if GetProcessName(ProcessList[i], ProcessName) <> 0 then
        ProcessName := rsUnknown;
      Listbox1.Items.Add(IntToStr(PID) + ' - ' + ProcessName);
    end;
  end
  else
    ShowMessage(SysErrorMessage(retValue));
end;
Die Prozesse auslesen und in eine Listbox einfügen.
Nun meine Frage wie kann ich diese dann beenden bit einen Button2?
  Mit Zitat antworten Zitat
Benutzerbild von arbu man
arbu man

Registriert seit: 3. Nov 2004
Ort: Krefeld
1.108 Beiträge
 
Delphi 7 Professional
 
#2

Re: Prozesse beenden

  Alt 24. Apr 2005, 14:35
Delphi-Quellcode:
var
  PrID: Integer;
  Ph: THandle;
begin
  // Prozess öffnen
  Ph := OpenProcess(1, BOOL(0), PrID);
  // Prozess terminieren
  Ret := TerminateProcess(Ph, 0);
end;
Einfach für PrID die Prozessid einsetzen
Björn
>> http://bsnx.net <<
Virtual DP Stammtisch v1.0"iw" am 19.09.2007 - ich war dabei!
  Mit Zitat antworten Zitat
Knotti2015
(Gast)

n/a Beiträge
 
#3

Re: Prozesse beenden

  Alt 24. Apr 2005, 14:39
Naja die Prid wird ja zuvor in dem string ausgelsen so müsste ich ja extra diese Angeben ich will sie aber durch ein OnClick auslesen...
  Mit Zitat antworten Zitat
ReDoX
(Gast)

n/a Beiträge
 
#4

Re: Prozesse beenden

  Alt 24. Apr 2005, 14:39
Es gibt mehrere Möglichkeinen Einen Prozess zu beenden.

1.Beendet den Prozess so als wenn du auf das [X] Klickst.

SendMessage(WND, WM_SYSCOMMAND, SC_CLOSE, 0);
2.Und es gibt die Möglichkeit einen Prozess mittels MSDN-Library durchsuchenTerminateProcess zu "killen".



Mfg ReDoX

[edit]@arbu man: Man sollte das handle mit CloseHandle(ph) schließen.[/edit]
  Mit Zitat antworten Zitat
Benutzerbild von JasonDX
JasonDX
(CodeLib-Manager)

Registriert seit: 5. Aug 2004
Ort: München
1.062 Beiträge
 
#5

Re: Prozesse beenden

  Alt 24. Apr 2005, 14:40
Die DP-Suche bringt: Den Tread mit folgendem Source:
Delphi-Quellcode:
{******************************************************************************} 
{**                                                                          **} 
{** ProzessID an Hand der Exe-Datei ermittlen                                **} 
{**                                                                          **} 
{******************************************************************************} 
function GetProcessID(sProcName: String): Integer;
var
  hProcSnap: THandle;
  pe32: TProcessEntry32;
begin
  result := -1;
  hProcSnap := CreateToolHelp32SnapShot(TH32CS_SNAPPROCESS, 0);
  if hProcSnap = INVALID_HANDLE_VALUE then exit;

  pe32.dwSize := SizeOf(ProcessEntry32);

  { wenn es geklappt hat } 
  if Process32First(hProcSnap, pe32) = true then
    { und los geht's: Prozess suchen} 
    while Process32Next(hProcSnap, pe32) = true do
    begin
      if pos(sProcName, pe32.szExeFile) <> 0then
        result := pe32.th32ProcessID;
    end;
CloseHandle(hProcSnap);
end;

{******************************************************************************} 
{**                                                                          **} 
{** Prozess beenden                                                          **} 
{**                                                                          **} 
{******************************************************************************} 
procedure KillProcess(dwProcID: DWORD);
var
  hProcess : Cardinal;
  dw : DWORD;
begin
  { open the process and store the process-handle } 
  hProcess := OpenProcess(SYNCHRONIZE or PROCESS_TERMINATE, False, dwProcID);
  { kill it } 
  TerminateProcess(hProcess, 0);
  { TerminateProcess returns immediately, so wie have to verify the result via
    WaitfForSingleObject }
 
  dw := WaitForSingleObject(hProcess, 5000);
  case dw of
    { everythings's all right, we killed the process } 
    WAIT_OBJECT_0: Messagebox(Application.Handle, 'Prozess wurde beendet.', 'Prozess beenden',
      MB_ICONINFORMATION);
    { process could not be terminated after 5 seconds } 
    WAIT_TIMEOUT:
    begin
      Messagebox(Application.Handle, 'Prozess konnte nicht innerhalb von 5 Sekunden beendet werden.',
        'Prozess beenden', MB_ICONSTOP);
      CloseHandle(hProcess);
      exit;
    end;
    { error in calling WaitForSingleObject } 
    WAIT_FAILED:
    begin
      RaiseLastOSError;
      CloseHandle(hProcess);
      exit;
    end;
  end;
  CloseHandle(hProcess);
  end;

procedure TForm1.Button1Click(Sender: TObject);
begin
    KillProcess(GetProcessID(edit1.text)); // in edit1 muss zb icq.exe stehen
end;
Mike
Passion is no replacement for reason
  Mit Zitat antworten Zitat
Benutzerbild von SirThornberry
SirThornberry
(Moderator)

Registriert seit: 23. Sep 2003
Ort: Bockwen
12.235 Beiträge
 
Delphi 2006 Professional
 
#6

Re: Prozesse beenden

  Alt 24. Apr 2005, 14:41
dann lese sie doch einfach durch einen klick aus. In der listbox steht ja dann ungefährt
"3040334 - Prozessname"
dementsprechend kannst du die Zeischen vor dem "-" wieder in eine Zahl zurückwandeln und der funktion "TerminateProcess" übergeben.
Jens
Mit Source ist es wie mit Kunst - Hauptsache der Künstler versteht's
  Mit Zitat antworten Zitat
Knotti2015
(Gast)

n/a Beiträge
 
#7

Re: Prozesse beenden

  Alt 24. Apr 2005, 14:44
Ja aber wie tue ich das. Es müsst ja erstmal der Prozess in der listbox ausgewählt, ausgelesen (1 - vmware), und dann die 1 an

Delphi-Quellcode:
var
  PrID: Integer;
  Ph: THandle;
begin
  // Prozess öffnen
  Ph := OpenProcess(1, BOOL(0), PrID);
  // Prozess terminieren
  Ret := TerminateProcess(Ph, 0);
end;
übergeben werden. Ich will nicht erst den Namen oder die ID eintragen einfach anklicken und drop...

  Mit Zitat antworten Zitat
Benutzerbild von JasonDX
JasonDX
(CodeLib-Manager)

Registriert seit: 5. Aug 2004
Ort: München
1.062 Beiträge
 
#8

Re: Prozesse beenden

  Alt 24. Apr 2005, 14:51
Falls du das auslesen der Zahl aus einem string wie '1 - asdf' brauchst, schau dir mal Delphi-Referenz durchsuchencopy, Delphi-Referenz durchsuchendelete und Delphi-Referenz durchsuchenpos an.

Zitat von Knotti2015:
Es müsst ja erstmal der Prozess in der listbox ausgewählt, ausgelesen (1 - vmware), und dann die 1 an (...) übergeben werden
Ich will nicht erst den Namen oder die ID eintragen einfach anklicken und drop
Was meinst du genau?
Du willst in der Listbox den Prozess anklicken und er soll beendet werden? (In der Listbox auswählen wird fast sein müssen )
Dann nimm nicht ein OnClick-Ereignis vom Button, sondern von der Listbox!
Den Prozess dann zu beenden dürftest du jetzt Möglichkeiten Genug haben. (durch exe-name, durch PID....)
Mike
Passion is no replacement for reason
  Mit Zitat antworten Zitat
Knotti2015
(Gast)

n/a Beiträge
 
#9

Re: Prozesse beenden

  Alt 24. Apr 2005, 14:54
Ja ich will es in der Listbox ja nur markieren und dann durch einen Button terminieren.
  Mit Zitat antworten Zitat
Benutzerbild von JasonDX
JasonDX
(CodeLib-Manager)

Registriert seit: 5. Aug 2004
Ort: München
1.062 Beiträge
 
#10

Re: Prozesse beenden

  Alt 24. Apr 2005, 14:57
Dann hilft dir:
  • Die oben angeführten Quellcodes
  • Das OnClick-Event von TButton
  • Die eigentschaft: TListbox.ItemIndex und TListbox.Items
Mike
Passion is no replacement for reason
  Mit Zitat antworten Zitat
Themen-Optionen Thema durchsuchen
Thema durchsuchen:

Erweiterte Suche
Ansicht

Forumregeln

Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are aus

Gehe zu:

Impressum · AGB · Datenschutz · Nach oben
Alle Zeitangaben in WEZ +1. Es ist jetzt 15:12 Uhr.
Powered by vBulletin® Copyright ©2000 - 2024, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2023 by Daniel R. Wolf, 2024 by Thomas Breitkreuz