C#

// Base class for all service classes
   public abstract class ServiceBase
   {
       public enum States
       {
           Cancelled,
           Processing,
           Stopped
       }

       #region Properties
       public States CurrentState { get; protected set; }

       public Guid ServiceId { get; private set; }

       public CancellationTokenSource CancellationTokenSource { get; private set; }
       #endregion

       #region CTOR
       public ServiceBase()
       {
           this.CurrentState = States.Stopped;
           this.ServiceId = Guid.NewGuid();
           this.CancellationTokenSource = new CancellationTokenSource();
       }
       #endregion

       #region Abstract Methods
       public abstract void Start();

       public abstract void Stop();
       #endregion

       #region Public Methods
       public void Cancel()
       {
           this.CurrentState = States.Cancelled;
           CancellationTokenSource.Cancel();
       }
       #endregion

       #region Private Methods
       protected bool CheckIfCancelled(bool throwIfCancelled = false)
       {
           bool cancelled = false;

           var token = CancellationTokenSource.Token;

           if (token.IsCancellationRequested)
           {
               cancelled = true;

               if (throwIfCancelled)
               {
                   token.ThrowIfCancellationRequested();
               }
           }

           return cancelled;
       }
       #endregion
   }

// Service class instance
public class MyService : ServiceBase
{
    #region Public Methods
    public override void Start()
    {
        // If the task has already been cancelled, then throw. This should never happen in my scenerio, but check anyway
        CheckIfCancelled(true);

        // Set the state to processing
        CurrentState = States.Processing;

        // Continue to do work as long as the task is not cancelled
        while (CurrentState == States.Processing)
        {
            if (CheckIfCancelled())
            {
                // Task has been cancelled, so break out of the loop
                break;
            }

            // Other code here
        }
    }

    public override void Stop()
    {
        // Stop processing, but don't cancel.
        CurrentState = States.Stopped;
    }
    #endregion
}

private static List<ServiceBase> _services;
static void Main(string[] args)
{
    _services = new List<ServiceBase>();

<pre>
//Create a bunch service instances

// LATER ON, WE CAN STOP OR CANCEL A SERVICE
private static ServiceBase GetServiceById(Guid serviceId)
{
    var service = _services.Where(x => x.ServiceId ==1 serviceId).FirstOrDefault();
    return service;
}

var s1 = GetServiceById(_services.FirstOrDefault().ServiceId);
s1.Stop();

var s2 = GetServiceById(_services.Last().ServiceId);
s1.Cancel();