ProcessInfo 1.3 is released. The changes in this release are:

• CPU usage is added to TProcessItem.
• Is64Bit is added to TProcessItem.
• IsAccessible is added to TProcessItem.
• Setting thread priority is added to TThreadItem.
• Setting process base priority class is added to TProcessItem.

To download ProcessInfo 1.3, please go to ProcessInfo page.

Q1: How can we find a module which is running a specific thread, giving a thread ID:

A: First of all, Threads are not assigned to modules, they are assigned to processes. You can find a process which is running the thread, by searching in the list of threads owned by each running process. Here is a sample code:

function FindProcessByThreadID(ID: Cardinal): TProcessItem;
var
  ProcessInfo : TProcessInfo;
  AProcess : TProcessItem;
begin
  Result := nil;
  ProcessInfo := TProcessInfo.Create(nil);
  try
    for AProcess in ProcessInfo.RunningProcesses do
    begin
      if Assigned(AProcess.Threads.FindByID(ID)) then
      begin
        Result := AProcess;
        Exit;
      end;
    end;
  finally
    ProcessInfo.Free;
  end;
end;

FindProcessByThreadID iterates over all running processes, and checks which of them has a thread with the given ID. If a process owns a thread with that ID, it will return that process as a TProcessItem object.

Once you have the process object, you can get more information about the process or the specific thread, or you can kill the process, or suspend the thread. For example:

var
  Process : TProcessItem;
begin
  Process := FindProcessByThreadID(StrToInt(3444));
  if Assigned(Process) then
    ShowMessage(Process.FullPath);
end;

The above code looks for a thread with its ID = 3444, and if it is found, it provides full path of the EXE file for that process.

Q2: How can we get memory consumption for a given process?

A: You can read memory info for a given process using TProcessItem.MemoryInfo. It provides different info about the memory the process is consuming. Here is an example for reading memory info of Google Chrome process while it is running :

var
  ProcessInfo : TProcessInfo;
  AProcess : TProcessItem;
begin
  ProcessInfo := TProcessInfo.Create(nil);
  try
    AProcess := ProcessInfo.RunningProcesses.FindByName('Chrome.exe');
    if Assigned(AProcess) then
      ShowMessage(Format('WorkingSet Size = %d, Peak WorkingSet Size = %d',
                         [AProcess.MemoryInfo.WorkingSetSize,
                          AProcess.MemoryInfo.PeakWorkingSetSize]));
  finally
    ProcessInfo.Free;
  end;
end;

First we search for Chrome.exe process among running processes. Once the process is found, we read its current working set size, and pick working set size through MemoryInfo property, and show them in a message box. The values returned are in Bytes.

Q3: How can we get process base priority class or change it?

A: You can access base priority class for a given process or modify it (added in version 1.3), using TProcessItem.

PriorityClassBase. Be careful, adjusting a base priority class of a given process inappropriately might make other processes unresponsive! Here is a example code:

var
  ProcessInfo : TProcessInfo;
  AProcess : TProcessItem;
begin
  ProcessInfo := TProcessInfo.Create(nil);
  try
    AProcess := ProcessInfo.RunningProcesses.FindByName('firefox.exe');
    if Assigned(AProcess) then
      AProcess.PriorityClassBase := BELOW_NORMAL_PRIORITY_CLASS;
  finally
    ProcessInfo.Free;
  end;
end;

You can also change each priority of  each thread within a process by setting BasePriority property of that TThreadItem instace.

Q4: How can I check if a process is 64-bit?

A: You can check this by reading TProcessItem.Is64Bits property.

Q5: How can I get CPU usage for a given process?

A: You can get CPU usage by reading TProcessItem.CPUUsage property.

I hope these few answers and sample source codes can help you use Process Info. For other examples of using Process Info, please refer to this post: How to use TProcessInfo

If there is any question regarding using Process Info, or anything about Delphi that you think worth being mentioned in Tips & Tricks section of this website, please contact me, and let me know about it.

Have Fun!

ProcessInfo 1.2 is released. The changes in this release are:

• SuspendThread, ResumeThread, TerminateThread methods are added to TThreadItem class. Now you can pause/resume/terminate any running thread in a given process.
• TProcessInfo.Active and TAppInfo.Active are published properties, and can be set in design mode.
• TProcessInfo.RunningProcesses and TAppInfo.RunningApplications automatically populate the corresponding list if UpdateList method is not called yet. This means even if you don’t activate any of these two components, or call their UpdateList method, accessing RunningProcesses or RunningApplications does not cause Access Violation.

To download ProcessInfo 1.2, please go to ProcessInfo page.

Regards.

This toolbar provides a nice search box which is able to filter components in the palette based on the search phrase. This toolbar is disabled by default, and is shown when Classic Layout is selected. Here you can see a snapshot of Classic Layout in RAD Studio 2010:

A few weeks ago while I was working with Delphi 2010, I noticed a delay when switching from code view to form designer. The delay was there not only in the complex forms, but also in simple empty forms! It was not a big delay (about 1 second), but since I had to switch between code and form designer view many times, it was really annoying, so I decided to investigate it and find out what is causing this delay.

At first I got suspected to CnPack toolbars in form designer and code view, so I disabled them, but it had no effect on the delay!  Then I went for SysInternals Process Monitor to monitor RAD Studio while switching from code view to form designer. There were many Registry activities regarding to component toolbar. At that time I was thinking about standard Tool Palette in RAD Studio 2010, not the classic component toolbar, because I was not using classic layout.

I tried to hide Tool Palette to see if it fixes the delay, but it didn’t! So I decided to disable its IDE package and see if it fixes the issue. While I was looking into the list of IDE packages in Registry, I found Component Toolbar Package, and I thought this is the package corresponding to Tool Palette. So I removed it from the list of known IDE packages, and restarted RAD Studio 2010; the Tool Palette was still there, BUT the switching delay was gone!

I was wondering if Component Toolbar was not related

to Tool Palette, then what was it related to?! Suddenly I remembered the new classic component toolbar, and switched to Classic Layout. Yes, it was the new classic component toolbar which was using Component Toolbar Package!

Since I don’t use classic view, I simply disabled this IDE package to have a faster switch time from code view to form designer. But still it is weird why this toolbar is being update even when it is not being visible, and why it is making switching from code view to form designer slower. This is definitely a bug in RAD Studio 2010.

How to disable an IDE package:

Here is how you can disable Component Toolbar Package from Registry:

1- Go to HKEY_CURRENT_USER\Software\CodeGear\BDS\7.0\Known IDE Packages.

2- Make a backup by right-clicking on “Known IDE Packages” key, and selecting  Export.

3- Find “$(BDS)\bin\comptoolbar140.bpl” value in “Known IDE Packages” key, and delete it.

4- Run RAD Studio 2010.

Regards

I released a new version of ProcessInfo. In this release I added these features:

• Enumerators are added for Windows, Threads, Modules, and Processes; Now you can use for-in statements in D2007 and above for iterating on running processes list, or modules\threads\windows of a given process.
• TProcessItem.UserName is added; This property returns domain name\user name which is running the process.
• TProocessInfo.AdjustDebugPrivilage is added; This method is called automatically.
  TThreadItem.ToString & TProcessItem.ToString are added; TThreadItem.ToString returns ThreadID. TProcess.ToString returns process EXE name.
• Now supports Delphi 7,2007,2009, 2010; Some conditional compiler directives are added so that it can be used in D7, 2007, 2009, and 2010. I tested it in D7, 2009, and 2010. It should work in D2007 too.

To download ProcessInfo 1.1, please go to ProcessInfo page.

Regards.

I thought maybe it is a good idea to talk about these components and some of their usages by providing some sample source codes. So I will start with TProcessInfo.

Updating running processes list automatically

TProcessInfo has an internal timer which can update processes list automatically. This timer is controlled by Active, and UpdateInterval properties. Active activates the internal timer, and UpdateInterval specifies update interval. The default value for UpdateInterval is 1000 (1 second).

To update the list manually, and not using the internal timer, you can call UpdateList method.

OnBeforeUpdate and OnAfterUpdate

TProcessInfo has two events. They both are invoked when UpdateList is called, either automatically by internal timer or manually by the programmer.

OnBeforeUpdate is invoked just before updating the list. It has a Cancel parameter which lets you to cancel updating. OnAfterUpdate is invoked when the list is updated. So if you have a control (e.g. a list view) that should show processes list, you can write its updating code in the event-handler of OnAfterUpdate.

Finding a running process

You can iterate over all running processes to find a specific process with specific characteristics, or use FindByID, and FindByName methods to find a process by its Process ID or Process Name:

var
  Process : TProcessItem;
begin
  Process := ProcessInfo1.RunningProcesses.FindByID(1234);
  if not Assigned(Process) then
    ShowMessage('No process found');
end;

Finding a process by its Process ID.

var
  Process : TProcessItem;
begin
  Process := ProcessInfo1.RunningProcesses.FindByName('Project3.exe');
  if not Assigned(Process) then
    ShowMessage('No process found');
end;

Finding a process by its Process Name.

var
  I: Integer;
  MemSize,
  MaxMemSize : Cardinal;
  ProcessName : string;
begin
  MaxMemSize := 0;
  for I := 0 to ProcessInfo1.RunningProcesses.Count - 1 do
  begin
    MemSize := ProcessInfo1.RunningProcesses[i].MemoryInfo.WorkingSetSize;
    if MemSize > MaxMemSize then
    begin
      MaxMemSize := MemSize;
      ProcessName := ProcessInfo1.RunningProcesses[i].ExeFile;
    end;
  end;
  ShowMessage(ProcessName + ‘uses more memory than other processes.’);
end; 

Finding the process which consumes more memory than others.

Terminating a running process

To terminate a running process, you should first find it in the list of running processes, and then call its TerminateProcess method:

 var
  Process : TProcessItem;
begin
  Process := ProcessInfo1.RunningProcesses.FindByName('notepad.exe');
  if Assigned(Process) then
    Process.TerminateProcess;
end;

Retrieving full path of a process

 var
  Process : TProcessItem;
begin
  Process := ProcessInfo1.RunningProcesses.FindByName('notepad.exe');
  if Assigned(Process) then
    ShowMessage(Process.FullPath);
end;

Listing modules which a process loaded

 var
  Process : TProcessItem;
  I: Integer;
begin
  Process := ProcessInfo1.RunningProcesses.FindByName('Project1.exe');
  if  Assigned(Process) then
  begin
    for I := 0 to Process.Modules.Count - 1 do
      Memo1.Lines.Add(Format('%d  : %s',[Process.Modules[i].BaseAddress,
                                         Process.Modules[i].ModuleName]));
  end;
end;

You can access other information about a process (e.g. Threads list, threads count, memory consumption, and so on) in the same way.
TAppInfo works very similar to TProcessInfo. I will try to explain it more with some examples in another article.

Process Info is a free Delphi component package containing two components:

• TProcessInfo
• TAppInfo

TProcessInfo provides a list of running processes. TAppInfo provides a list running applications (similar to Application tab in Windows Task Manager). Both components can update their list frequently based on the value of Interval property.

TProcessInfo returns a collection of TProcessItem objects. Each instance of TProcessItem provides these information and actions for the process:

• Creation time
• Kernel time
• User time
• EXE file name
• Full image path
• Process ID
• Parent process ID
• Terminate process
• Threads count
• UserName
• Modules list (TModuleItem)
  • Base address
  • Base size
  • Handle
  • Load count
  • Module ID
  • Module path
  • ProcessID
• Threads list (TThreadItem)
  • Base priority
  • Parent process ID
  • Resume thread
  • Suspend thread
  • Terminate thread
  • Thread ID
• Memory info (TMemoryInfo)
  • Page Fault Count
  • Peak Working Set Size
  • Working Set Size
  • Quota Peak Paged Pool Usage
  • Quota Paged Pool Usage
  • Quota Peak Non-paged Pool Usage
  • Quota Non-paged Pool Usage
  • Page file Usage
  • Peak Page file Usage
• Base priority

TAppInfo returns a collection of TWindowItem. Each instance of TWindowItem provides these information for the window:

• Window caption
• Application path
• Process ID
• Window handle
• Window class

A simple demo is also included which shows basic functionalities of TProcessInfo, and TAppInfo by creating a simple task manager. Demo is tested on Delphi 7, Delphi 2009, and Delphi 2010.

Process Info is published under the Creative Commons Attribution 3.0 Unported License.

Update:

• 2010/07/26: Version 1.3
• 2010/01/13: Version 1.2
• 2009/10/17: Version 1.1

Download:

Download Process Info (Source + Demo)

در این مقاله تعریف مختصری از مفهوم Interface و Abstract Class در طراحی نرم افزار ارائه می کنیم، و سپس به قابلیت های نوع Interface در دلفی و برخی کاربردهای آن، با ذکر مثال، می پردازیم.

مقدمه

نوع Interface از نسخه ۳ به دلفی اضافه شد تا پشتیبانی از تکنولوژی COM شرکت مایکروسافت در دلفی فراهم شود. Interface علاوه بر پشتیبانی از COM، قابلیت های جالبی برای برنامه نویسان دلفی به ارمغان آورد که کمتر از آن استفاده می شود. متاسفانه به دلیل آنکه چارچوب اصلی VCL و بخصوص کامپوننت های کار با بانک اطلاعاتی دلفی مدت ها قبل از آن (از نسخه اول دلفی) ایجاد شده بودند، استفاده چندانی از Interfaceها در VCL صورت نگرفت.

برای درک بهتر interface ها، و قبل از آنکه به تعریف Interface و کاربردهای آن بپردازیم، ابتدا به مفهوم کلاس های Abstract و تعریف آنها اشاره ایی خواهیم داشت؛ زیرا مشابهت هایی در کاربرد این دو مفهوم وجود دارد، و شناخت مفهوم کلاس های Abstract درک مفهوم Interfaceها را ساده تر می کند.

TBaseWindow = class
private
  AField  : TSomeType;
public
  procedure Draw; virtual;
  procedure Minimize;
  procedure Maximize;
  procedure Restore;
end;

TBaseWindow = class
private
  AField  : TSomeType;
public
  procedure Draw; virtual; abstract;
  procedure Minimize;
  procedure Maximize;
  procedure Restore;
end;

I4wd = interface
   ['{C2816773-A5DF-4136-AC86-27E6231DB4A9}']
   procedure Initialize4WD;
end;

TCar = class(TInterfacedObject)
public
   procedure SomeCommonBehavior;
   procedure StartEngine; virtual;
end;

TSedan = class(TCar)
public
  procedure SomeSpecificBehavior;
  procedure StartEngine; override;
end;

TSUV = class(TCar, I4wd)
public
   procedure SomeSpecificBehavior;
   procedure StartEngine; override;
   procedure Initialize4WD;
end;

TVan = class(TCar, I4wd)
public
  procedure SomeSpecificBehavior;
  procedure Initialize4WD;
end;

{نحوه استفاده}

procedure Drive4WD(A4WDCar : I4WD);
begin
  if Assigned(A4WDCar) then
  begin
     A4WDCar.Initialize4WD;
    {Add Code for driving the car here}
  end;
end;

var
SUV : TSUV;
A4wdInterface : I4WD;
begin
  {If TSuv implements I4WD (supports it), extract the interface.}
  if Supports(TSUV.Create,I4WD,A4wdInterface) then
  {Invoke Initialize4WD from returned interface.}
  A4wdInterface.Initialize4WD;

  //----------------------------------
  {Just check if TSuv supports I4WD, no interface is returned.}
  if Supports(TSuv,I4WD) then
  ShowMessage('TSuv supports I4WD interface');

  //----------------------------------
  SUV := TSUV.Create;
  {If you are sure than SUV supports I4WD, use as operator to extract
  the interface and invoke Initialize4WD.
  If SUV does not support I4WD, an exception will be thrown.}
  (SUV as I4wd).Initialize4WD;

  //----------------------------------
  SUV := TSUV.Create;
  {If Suv implements I4WD (supports it), extract the interface.}
  if SUV.GetInterface(I4WD,A4wdInterface) then
  A4wdInterface.Initialize4WD;

  //----------------------------------
  {TSUV supports I4WD, so you can assign an instance of it to a variable of type I4WD.}
  A4wdInterface := TSuv.Create;
  A4wdInterface.Initialize4WD;
end;

TMyMobile = class(TInterfaceObject, IInfraRed, IBlueTooth)
  {TMobile's fields and methods + IInfraRed's methods + IBlueThoot's methods}
end;

procedure TForm1.Button3Click(Sender: TObject);
var
  SUV : TSUV;
  Van : TVan;
  AnInterface,
  AnotherInterface : I4WD;
begin
  Memo1.Clear;
  SUV := TSuv.Create;
  //SUV.RefCount = 0
  AnInterface := SUV;
  //SUV.RefCount = 1
  AnotherInterface := SUV;
  //SUV.RefCount = 2

  Van := TVan.Create;
  //Van.RefCount = 0;
  AnInterface := Van;
  //SUV.RefCount = 1
  //Van.RefCount = 1
end;
//" AnInterface" is out of scope: SUV.RefCount = 0
//SUV is destroyed
//AnotherInterface is out of scope: Van.RefCount = 0
//Van is destroyed

unit mtReaper;

interface

type
ImtReaper = interface
  ['{1B321324-975F-4026-B742-E7B3AD486BB5}']
end;

TmtReaper = class(TInterfacedObject, ImtReaper)
private
  FObject : TObject;
public
  constructor Create(AObject : TObject);
  destructor Destroy; override;
end;

implementation

uses SysUtils;

constructor TmtReaper.Create(AObject: TObject);
begin
  FObject := AObject;
end;

destructor TmtReaper.Destroy;
begin
  FreeAndNil(FObject);
  inherited;
end;

end.

var
  List : TStringList;
  mtReaper : ImtReaper;
begin
  List := TStringList.Create;
  mtReaper := TmtReaper.Create(List);

  //Use List in your code
  List.LoadFromFile('A File Name');
  List.Sort;
end;
//List will be destroyed automatically by mtReaper