private bool IsWokerProccesAlive()
        {
            bool isAlive = false;

            foreach (Process process in Process.GetProcessesByName(WorkerProccessName))
            {
                isAlive = true;
                process.Dispose();
            }

            if (isAlive)
            {
                WorkerProcessClient client = CreateWorkerProcessClient();

                try
                {
                    client.Endpoint.Binding.OpenTimeout    = new TimeSpan(0, 0, 2);
                    client.Endpoint.Binding.SendTimeout    = new TimeSpan(0, 0, 2);
                    client.Endpoint.Binding.ReceiveTimeout = new TimeSpan(0, 0, 2);
                    client.Endpoint.Binding.CloseTimeout   = new TimeSpan(0, 0, 2);

                    client.Open();

                    return(client.IsAlive());
                }
                catch
                {
                    isAlive = false;
                }
            }

            return(isAlive);
        }
        private LCAWrapperResult SendGroupToWorkerProcess(IList <PBROW> rows, IList <AISLE_WAYPOINT> waypoints, LCASettings lcaSettings)
        {
            LCAWrapperResult lcaResult = new LCAWrapperResult(new List <LCAWrapperResultLine>(), new Dictionary <int, List <string> >());

            _processingLock.AcquireReaderLock(-1);

            bool recycle = false;

            lock (_syncLock)
            {
                if (!_isRecycling)
                {
                    if (!IsWokerProccesAlive())
                    {
                        AbortClients();
                        recycle = true;
                    }
                    else if (_processCount == _recycleThresholdWP + 1)
                    {
                        recycle = true;
                    }
                    else
                    {
                        _processCount++;
                    }

                    _isRecycling = recycle;
                }
            }

            if (recycle)
            {
                LockCookie cookie = _processingLock.UpgradeToWriterLock(-1);

                _isRecycling = false;

                try
                {
                    Tracing.TraceEvent(TraceEventType.Verbose, 0, "Recycling worker process...");

                    CreateWorkerProcess();

                    Tracing.TraceEvent(TraceEventType.Verbose, 0, "Done recycling worker process.");
                }
                finally
                {
                    _processingLock.DowngradeFromWriterLock(ref cookie);
                }
            }


            WorkerProcessClient client = CreateWorkerProcessClient();

            try
            {
                lock (_clientList)
                {
                    _clientList.Add(client);
                }

                client.Open();

                try
                {
                    lcaResult = client.ProcessGroup(rows, waypoints, lcaSettings);
                }
                catch (TimeoutException)
                {
                    Tracing.TraceEvent(TraceEventType.Warning, 0, "Timed out while processing group");
                    throw;
                }
            }
            finally
            {
                lock (_clientList)
                {
                    _clientList.Remove(client);
                }

                try
                {
                    client.Close();
                }
                catch (TimeoutException)
                {
                    client.Abort();
                }
                catch (CommunicationException)
                {
                    client.Abort();
                }
            }

            return(lcaResult);
        }
        private void DisposeWorkerProcess()
        {
            if (_workerProcess != null)
            {
                try
                {
                    Tracing.TraceEvent(TraceEventType.Verbose, 0, "Disposing worker process...");

                    WorkerProcessClient client = CreateWorkerProcessClient();

                    try
                    {
                        client.Endpoint.Binding.OpenTimeout    = new TimeSpan(0, 0, 5);
                        client.Endpoint.Binding.SendTimeout    = new TimeSpan(0, 0, 5);
                        client.Endpoint.Binding.ReceiveTimeout = new TimeSpan(0, 0, 5);
                        client.Endpoint.Binding.CloseTimeout   = new TimeSpan(0, 0, 5);

                        client.Open();

                        client.Terminate();

                        _workerProcess.WaitForExit(5000);
                    }
                    finally
                    {
                        try
                        {
                            client.Close();
                        }
                        catch (TimeoutException)
                        {
                            client.Abort();
                        }
                        catch (CommunicationException)
                        {
                            client.Abort();
                        }
                    }
                }
                catch
                {
                }
                finally
                {
                    try
                    {
                        if (!_workerProcess.HasExited)
                        {
                            _workerProcess.Kill();
                        }
                    }
                    catch
                    {
                    }
                    finally
                    {
                        _workerProcess.Dispose();
                    }
                }
            }
        }