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();

<?xml version="1.0" encoding="utf-8"?>
<ArrayOfService xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
                xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <Service>
    <ServiceName>TestClass1</ServiceName>
    <ServiceId>59182d7e-8874-4d40-bdba-44936bcce815</ServiceId>
    <AssemblyName>Services.Test.dll</AssemblyName>
    <State>Ready</State>
  </Service>
</ArrayOfService>

public interface IService
{
    event EventHandler<ServiceMessageModel> StatusChanged;

    string ServiceName { get; set; }

    Guid ServiceId { get; set; }

    ServiceState State { get; set; }

    void Start();

    void Stop();
}

private void LoadServices()
{
    _services = new List<IService>();

    string[] files = Directory.GetFiles(_servicesLocation, "*.dll");

    foreach (string file in files)
    {
        var assemblyExistsInManifest = _manifest.Where(x => file.Contains(x.AssemblyName)).Any();
        if (assemblyExistsInManifest)
        {
            Assembly assembly = Assembly.LoadFrom(file);
            var types = assembly.GetTypes();

            foreach (Type type in types)
            {
                var typeExistsInManifest = _manifest.Where(x => type.ToString().Contains(x.ServiceName)).Any();

                var implementsInterface = typeof(IService).IsAssignableFrom(type);

                if (typeExistsInManifest && implementsInterface)

                    var serviceClass = Activator.CreateInstance(type) as IService;
                    serviceClass.StatusChanged += ServiceClass_StatusChanged;

                    _services.Add(serviceClass);
                }
            }
        }
    }
}

private void StartAllServices()
{
    foreach (var service in _services)
    {
        Task.Factory.StartNew(() =>
        {
            service.Start();

        });
    }
}

private void CancelService(Guid serviceId)
{
    // Find the service class for the speified Id
    var service = _services.FirstOrDefault(x => x.ServiceId == serviceId);

    // If it was found...
    if (service != null)
    {
        // Cancel the task
        var ct = service.CancellationToken; // Get the token off the service.
        ct.Cancel();
    }
}

var serviceClass = Activator.CreateInstance(type) as IInstrumentService;
_services.Add(serviceClass);

private void StartAllServices()
{
    foreach (var service in _services)
    {
        Task.Factory.StartNew(() =>
        {
            service.Start();

        }).ContinueWith(task =>
        {
            if (task.Exception != null)
            {
                // Handle the exception here
            }
        });
    }
}