Writing Windows services is a common task for Delphi developers. A service is a program that runs in the background without user interface and is managed by the Windows Service Controller. Typical uses for services include monitoring system events, communication with other systems, and background processing tasks.
Delphi makes writing services straightforward with built-in support and design tools. This article provides an overview of how to write a basic Windows service in Delphi from installation to management. We will cover key concepts like the service life cycle, controlling service startup and shutdown, responding to control events, exception handling, logging, and more.
Getting Started
To write a service, start by creating a new VCL Forms Application project in Delphi. Next, go to the Project > Options dialog and change the application type to ‘Service Application’. This will enable service-specific properties and functionality.
The main form created by default will be renamed to represent the service controller for development purposes. Add a TServerContainer component which represents the core Windows service runtime environment. Drop any additional components or classes needed for the core service logic onto the form as well.
A service always requires a main execution thread separate from the Windows message loop. Services do not have windows or user interfaces. To provide the service thread, override the TServerContainer’s OnCreate/OnDestroy handlers:
procedure TForm1.ServerContainer1Create(Sender: TObject);
begin
ServiceThread := TThread.CreateAnonymousThread(
procedure
begin
ServiceMain;
end
);
end;
procedure TForm1.ServerContainer1Destroy(Sender: TObject);
begin
ServiceThread.Free;
end;
The ServiceMain procedure would contain the main service logic, monitoring, processing etc. It executes independently without blocking the main thread.
Installation and Registration
Before a service can run, it must be properly installed and registered in Windows. This associates the executable with service functions. To install at design time:
Go to Project > View Source to switch to code view.
Add {$R *.res} to the uses clause to reference the manifest resource.
Add a MANIFESTRESOURCE statement below to embed the manifest.
{ MANIFEST INFORMATION }
{$R *.RES}
MANIFESTRESOURCE ‘service.manifest’;
The ‘service.manifest’ file contains metadata to mark the app as a service. It will be compiled into the executable.
Next, open a command prompt as Administrator and navigate to the build folder. Run:
MyService.exe install
This will register the service binaries and configuration with Windows. The service will now appear in Administrative Tools > Services and can be controlled there.
Service Life Cycle Events
A service must respond to specific life cycle events sent by the SCM (Service Control Manager). Override handlers in the TServerContainer to implement these:
procedure TForm1.ServerContainer1Start(Sender: TObject);
begin
// Start service logic thread
end;
procedure TForm1.ServerContainer1Stop(Sender: TObject);
begin
// Stop service logic thread
end;
procedure TForm1.ServerContainer1Pause(Sender: TObject);
begin
// Pause service logic
end;
procedure TForm1.ServerContainer1Continue(Sender: TObject);
begin
// Resume paused service
end;
The Start event runs when the service is started. Stop is called on service shutdown. Pause and Continue events allow temporarily stopping service work.
A service should exit both Start and Stop handlers quickly to return control back to SCM promptly. Perform actual work asynchronously on a thread pool or background threads.
Logging and Exception Handling
Proper logging is critical for services that may run unattended for long periods. Use an industry-standard logging framework like Log4Delphi to abstract logging implementation.
Log messages to the Windows event log, debug output, or log files. Key events to log include service startup/shutdown, configuration changes, errors/exceptions. Log liberally in development, and reduce verbose logs in production for performance.
Handle any exceptions gracefully – services should never crash unexpectedly. The typical approach is to log exceptions, clean up resources, and return control back to SCM as quickly as possible on errors without hanging.
To avoid exceptions bringing down the whole process unexpectedly, run service logic code inside exception-wrapped try/except blocks:
try
// service logic thread
except
on E: Exception do
begin
LogError(‘Unhandled exception’, E);
end;
end;
Configuration and Settings
Many services require configuration options and settings that can be modified without recompilation/restarting. The TServerContainer provides a Configuration property to store name/value configuration pairs.
Declare a public section to expose configuration properties:
type
TForm1 = class(TForm)
ServerContainer1: TServerContainer;
private
{ Private declarations }
protected
procedure GetServiceController(AService: TService;
Proc: TGetServiceProc; var ServiceController: TServiceController); override;
public
{ Public declarations }
published
property ConnectionString: String
read Configuration.Values[‘ConnectionString’]
write Configuration.Values[‘ConnectionString’];
end;
The Configuration values can now be modified at runtime through the service properties sheet in Services MMC snap-in. Additional configuration files or registry keys can also be used.
Service Control and Communications
Services frequently need to communicate status, accept control requests, and signal other processes or services. The TServerContainer events allow responding to SCM control operations like start/stop.
To support additional commands, expose functions that external processes can call using RPC, Remoting, named pipes, sockets etc. For example, implement control logic in a service method:
function TForm1.ServiceRefreshData: Boolean;
begin
// refresh data logic
Result := True;
end;
External processes could then call ServiceRefreshData remotely to trigger a data refresh. Windows communication APIs like named pipes provide secure cross-process calling for services.
Services may also log status/progress to a central monitoring system using MQTT, REST, queues etc. Consider decoupling status updates from the core service threads using worker threads or background tasks to prevent blocking.
Deployment and Management
Delivery a complete service package tailored for automated setups and upgrades. Bundle the service executable, configuration files, installation/removal scripts, and any other dependent files into a single deployment package.
Script the full install/uninstall flow handling dependencies, configuration, registering/de-registering components with the SCM automatically. Consider using tools like Inno Setup, WiX or InstallShield to generate Windows installers for simplified one-click deployment.
Logging and monitoring are essential for operational services. Centralize logs from multiple instances using log shippers or forwarding to log aggregation systems like Elasticsearch. Monitor services using a system like Nagios, Sensu or Prometheus for uptime/health checks.
Alert on failure conditions using notifications to on-call personnel. For critical infrastructure services aim for automated self-healing using techniques like process respawning, automatic failovers and rollback mechanisms on errors.
In Summary
Delphi makes writing Windows services straightforward through its built-in service application type and TServerContainer component. Key aspects are responding to the service life cycle callbacks, properly installing and managing the service registration, multi-threaded asynchronous logic design, robust error handling and logging facilities. With these fundamentals, developers can reliably author long-running background services and system services.
Andrew Stroud