Distributed and Parallel Processing using WCF

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data.SqlClient;
using System.Threading;

namespace Master
{
    /// <summary>
    /// This is the job distributer.
    /// </summary>
    public class JobDistributer
    {
        /// <summary>
        /// This is the proxy to the client.
        /// </summary>
        ServiceReference.JobPerformerClient jobPerformerClient
            = new global::Master.ServiceReference.JobPerformerClient();
 
        /// <summary>
        /// This is the number of active threads in the system.
        /// </summary>
        private int threadCount = 0;

        /// <summary>
        /// This is the number of active threads in the system.
        /// </summary>
        public int ThreadCount
        {
            get
            {
                return threadCount;
            }

        }

        /// <summary>
        /// This tells if an error has occured in the processing.
        /// </summary>
        int hasErrorOccured = 0;

        public int HasErrorOccured
        {
            get
            {
                return hasErrorOccured;
            }
        }

        /// <summary>
        /// The status of no error occured
        /// </summary>
        int statusNoError = 0;

        /// <summary>
        /// This is the init where the async registration takes place.
        /// </summary>
        public JobDistributer()
        {
            jobPerformerClient.SaveEntriesCompleted += new EventHandler<global::Master.ServiceReference.SaveEntriesCompletedEventArgs>(jobPerformerClient_SaveEntriesCompleted);
        }

        /// <summary>
        /// This method is called when execution is completed.
        /// </summary>
        /// <param name="sender">This is the sender</param>
        /// <param name="e">This is the result</param>
        void jobPerformerClient_SaveEntriesCompleted(object sender, global::Master.ServiceReference.SaveEntriesCompletedEventArgs e)
        {
            //decrement the thread count
            Interlocked.Decrement(ref threadCount);
            //if an error has not occured
            if (hasErrorOccured == 0)
            {
                //if an error took place then set the value as error occured.
                if (e.Result == false)
                {
                    Interlocked.Increment(ref hasErrorOccured);
                }
            }
        }

        /// <summary>
        /// This method is called to execute request.
        /// </summary>
        /// <param name="fileId">The Id of the file.</param>
        /// <param name="message">The message to be sent.</param>
        /// <param name="count">The count.</param>
        public void RequestExecution(int fileId,string message,int count)
        {
            //Increase the thread count
            Interlocked.Increment(ref threadCount);
            //call to save the message
            jobPerformerClient.SaveEntriesAsync(fileId, message, count);
        }
    }
}