Development of the service application involves the following steps:

Despite having a Main method, service code cannot be executed directly; the ServiceBase.Run call causes a Windows Service Start Failure dialog to appear. The service must be installed before it can execute; we cover installation in the next section.

No lengthy processing should be carried out in the Main method or the instance constructor, nor should the service functionality be started until instructed by the SCM.

The creation of a service is best explained by example, so we’ll develop two simple services that exist in a single assembly. Despite being defined in a single assembly, each service is independently controlled via the SCM. We have called one service LogBeacon1 and the other LogBeacon2.

Both the LogBeacon1 and LogBeacon2 services are instances of the BeaconService class that derives from ServiceBase. When instantiated, the BeaconService class creates a thread that periodically writes entries to the Application event log; the activity of the logging thread is controlled by commands from the SCM. The BeaconService code is listed here; a discussion of the code follows.

using System;
using System.Threading;
using System.ServiceProcess;

public class BeaconService : ServiceBase {

    private Thread BeaconThread = null;
    private int Interval = 5000;

    public BeaconService(String name) {
        ServiceName = name;
        CanStop = true;
        CanPauseAndContinue = true;
        BeaconThread = new Thread(new ThreadStart(Beacon));
    }

    protected override void OnStart(String[] args) {
        if (BeaconThread != null) {
            BeaconThread.Start();
        }
    }

    protected override void OnStop() {
        if (BeaconThread != null) {
            BeaconThread.Abort();
        }
    }

    protected override void OnPause() {
        if (BeaconThread != null) {
            BeaconThread.Suspend();
        }
    }

    protected override void OnContinue() {
        if (BeaconThread != null) {
            BeaconThread.Resume();
        }
    }

    private void Beacon() {
        while (true) {
            EventLog.WriteEntry(ServiceName + " active at "
                + DateTime.Now);
            Thread.Sleep(Interval);
        }
    }

    public static void Main() {

        // Create an array to hold instances of each
        // Windows Service
        ServiceBase [] ServiceList = new ServiceBase [2];

        ServiceList[0] = new BeaconService("LogBeacon1");
        ServiceList[1] = new BeaconService("LogBeacon2");

        ServiceBase.Run(ServiceList);
    }
}

The Main method creates two BeaconService instances, one for each of the services. We pass the service name as an argument to the BeaconService constructor; this is used to set the value of the inherited ServiceName property. ServiceName is the name the SCM uses internally to identify the service.

In the BeaconService constructor, we have set the value of the inherited CanStop and CanPauseAndContinue properties to true. The SCM uses these properties to determine the life cycle control messages that the service can process. These properties as well as the CanShutdown and CanHandlePowerEvent properties are summarized in Table A-10.

The SCM controls the operation of a service via a set of methods inherited from ServiceBase. However, the SCM will call only those methods that the service has indicated it supports via the properties just discussed. Each of these methods is summarized in Table A-11.

We override the OnStart method to initiate the functionality of the service; we also override the OnStop, OnPause, and OnContinue methods because the CanStop and CanPauseAndContinue properties are set to true. In the example, we use methods of the Thread class to start, abort, suspend, or resume the operation of the logging thread in response to each SCM message.

Finally, in the Main method, references to the new BeaconService instances are placed in a ServiceBase array and passed as an argument to the static ServiceBase.Run method. The Run method calls the SCM and passes it the references to the two services.

Services cannot be executed like other assemblies; the tight integration with the operating system and the configuration information held in the Windows registry requires that they be explicitly installed.

A service installer class must be developed and compiled into the assembly containing the service class. Once the installer class is compiled, the Installer Tool (installutil.exe) provided with the .NET SDK is used to install the service.

An installer class must

Note that a Main method is not required; the installutil tool instantiates the installer, so all logic should be contained in the instance constructor.

The following code provides an installer for the BeaconService service:

using System.ServiceProcess;
using System.Configuration.Install;
using System.ComponentModel;

[RunInstaller(true)]
public class BeaconServiceInstaller : Installer {

    // Create a ServiceProcessInstaller for each application
    private ServiceProcessInstaller BeaconProcess = null;

    // Create a ServiceInstaller instance for each
    // service contained in the application
    private ServiceInstaller BeaconLogService1 = null;
    private ServiceInstaller BeaconLogService2 = null;

    public BeaconServiceInstaller() {

        // Instantiate and configure the ServiceProcessInstaller
        BeaconProcess = new ServiceProcessInstaller();
        BeaconProcess.Account = ServiceAccount.LocalSystem;

        // Instantiate and configure the ServiceInstaller for the
        // First Event Log Beacon
        BeaconLogService1 = new ServiceInstaller();
        BeaconLogService1.DisplayName = "Log Beacon 1";
        BeaconLogService1.ServiceName = "LogBeacon1";
        BeaconLogService1.StartType = ServiceStartMode.Automatic;

        // Instantiate and configure the ServiceInstaller for the
        // Second Event Log Beacon
        BeaconLogService2 = new ServiceInstaller();
        BeaconLogService2.DisplayName = "Log Beacon 2";
        BeaconLogService2.ServiceName = "LogBeacon2";
        BeaconLogService2.StartType = ServiceStartMode.Automatic;

        // Add the installers to the Installers collection
        Installers.Add(BeaconLogService1);
        Installers.Add(BeaconLogService2);
        Installers.Add(BeaconProcess);
    }
}

csc /out:Beacon.exe BeaconService.cs BeaconInstaller.cs

installutil Beacon.exe

installutil /u Beacon.exe

Various tools included with Microsoft Windows provide basic service configuration and life cycle control. However, services can also be controlled programmatically, often via a service-specific management interface. Implementation of a service controller is the only way to send custom commands to a service via the ServiceBase.OnCustomCommand method described earlier.

The System.ServiceProcess.ServiceController class provides the functionality to query and control installed services on both local and remote machines.

Instances of the ServiceController class represent installed services. The ServiceController instance can be bound to a specified local or remote service during construction or by changing the ServiceName and MachineName properties after instantiation. Changing the MachineName and ServiceName of a bound instance will bind to the newly specified service.

ServiceController also provides the static GetServices method that returns a ServiceController array representing all the services installed on a local or remote machine.

Once a ServiceController is instantiated and bound to an installed service, the members detailed in Table A-15 can be used to control and query the service.