BlueCollar.Worker.Stop C# (CSharp) Метод

        public void Stop(bool force)
        {
            if (this.disposed)
            {
                throw new ObjectDisposedException("Worker");
            }

            bool isWorking = false, isAlive = false;

            lock (this.statusLocker)
            {
                if (this.Status == WorkerStatus.Working)
                {
                    isWorking = true;
                    this.SetStatus(WorkerStatus.Stopping);
                }
            }

            lock (this.runLocker)
            {
                isAlive = this.runThread != null && this.runThread.IsAlive;
            }

            if (isWorking && isAlive)
            {
                if (!force)
                {
                    try
                    {
                        this.runThread.Join();
                        this.runThread = null;
                    }
                    catch (NullReferenceException)
                    {
                    }
                }
                else
                {
                    this.KillRunThread();
                }
            }

            lock (this.statusLocker)
            {
                lock (this.runLocker)
                {
                    WorkingRecord record = this.currentRecord;

                    using (IRepository repository = this.repositoryFactory.Create())
                    {
                        using (IDbTransaction transaction = repository.BeginTransaction())
                        {
                            if (record != null)
                            {
                                HistoryRecord history = CreateHistory(record, HistoryStatus.Interrupted);
                                repository.DeleteWorking(record.Id.Value, transaction);
                                history = repository.CreateHistory(history, transaction);
                            }

                            this.SetStatus(WorkerStatus.Stopped, repository, transaction);
                            transaction.Commit();
                        }
                    }

                    this.currentRecord = null;
                }
            }

            if (isWorking)
            {
                this.logger.Info("Worker {0} ({1}) has stopped.", this.name, this.id);
            }
        }

        public void WorkerDispose()
        {
            IJob job = new TestJob() { Id = Guid.NewGuid() };
            SignalsRecord signals = new SignalsRecord() { QueueNames = "*", WorkerSignal = WorkerSignal.None, WorkingSignal = WorkingSignal.None };

            QueueRecord queued = new QueueRecord()
            {
                Id = 12,
                ApplicationName = BlueCollarSection.Section.ApplicationName,
                Data = JsonConvert.SerializeObject(job),
                JobName = job.Name,
                JobType = JobSerializer.GetTypeName(job.GetType()),
                QueuedOn = DateTime.UtcNow,
                QueueName = "*",
                TryNumber = 1
            };

            var transaction = new Mock<IDbTransaction>();

            var repository = new Mock<IRepository>();
            repository.Setup(r => r.BeginTransaction()).Returns(transaction.Object);
            repository.Setup(r => r.BeginTransaction(It.IsAny<IsolationLevel>())).Returns(transaction.Object);
            repository.Setup(r => r.GetQueued(It.IsAny<string>(), It.IsAny<QueueNameFilters>(), It.IsAny<DateTime>(), It.IsAny<IDbTransaction>())).Returns(queued);
            repository.Setup(r => r.GetWorkingSignals(It.IsAny<long>(), It.IsAny<long?>(), It.IsAny<IDbTransaction>())).Returns(signals);

            var factory = new Mock<IRepositoryFactory>();
            factory.Setup(f => f.Create()).Returns(repository.Object);

            var logger = new Mock<ILogger>();
            Worker worker = null;

            try
            {
                worker = new Worker(BlueCollarSection.Section.ApplicationName, 1, "Test Worker", null, 1, false, factory.Object, logger.Object);
                worker.Start();
                Thread.Sleep(1500);
                worker.Stop(false);
                worker.Dispose();

                Assert.IsFalse(worker.LoopThreadsAreAlive);
                worker = null;
            }
            finally
            {
                if (worker != null)
                {
                    worker.Dispose();
                }
            }
        }