WoWHeadParser.Worker.Start C# (CSharp) Метод

        public unsafe void Start()
        {
            if (m_isWorking)
                throw new InvalidOperationException("_isWorking");

            m_isWorking = true;
            m_timeStart = DateTime.Now;

            switch (m_type)
            {
                case ParsingType.TypeBySingleValue:
                    {
                        Process(m_value.Id);
                        break;
                    }
                case ParsingType.TypeByMultipleValue:
                    {

                        for (uint entry = m_value.Start; entry <= m_value.End; ++entry)
                        {
                            if (!Process(entry))
                                break;
                        }
                        break;
                    }
                case ParsingType.TypeByList:
                    {
                        for (int i = 0; i < m_value.Array.Length; ++i)
                        {
                            if (!Process(m_value.Array[i]))
                                break;
                        }
                        break;
                    }
                case ParsingType.TypeByWoWHeadFilter:
                    {
                        for (uint entry = 0; entry <= m_value.Maximum; ++entry)
                        {
                            if (!Process(entry))
                                break;
                        }
                        break;
                    }
            }

            while (m_semaphore.CurrentCount != SemaphoreCount)
            {
                Application.DoEvents();
            }

            if (m_storeUnprocessedIds)
            {
                while (m_badIds.Count > 0)
                {
                    if (!m_isWorking)
                        break;

                    uint id = m_badIds.Dequeue();
                    if (id == 0)
                        continue;

                    if (!Process(id))
                        break;
                }
            }

            while (m_semaphore.CurrentCount != SemaphoreCount)
            {
                Application.DoEvents();
            }

            m_timeEnd = DateTime.Now;
        }

        private void BackgroundWorkerDoWork(object sender, DoWorkEventArgs e)
        {
            string      locale = (string)localeBox.SelectedItem;
            ParsingType type   = (ParsingType)parsingControl.SelectedIndex;

            _parser = (Parser)Activator.CreateInstance((Type)parserBox.SelectedItem);
            if (_parser == null)
            {
                throw new ArgumentNullException();
            }

            string address = string.Format("http://{0}{1}", (string.IsNullOrEmpty(locale) ? "www." : locale), _parser.Address);

            switch (type)
            {
            case ParsingType.TypeSingle:
            {
                uint value = (uint)valueBox.Value;
                _worker = new Worker(value, address);
                break;
            }

            case ParsingType.TypeList:
            {
                progressBar.Maximum = _entries.Count;

                _worker = new Worker(_entries, address);
                break;
            }

            case ParsingType.TypeMultiple:
            {
                uint startValue = (uint)rangeStart.Value;
                uint endValue   = (uint)rangeEnd.Value;

                if (startValue > endValue)
                {
                    throw new ArgumentOutOfRangeException(@"Starting value can not be bigger than ending value!");
                }

                if (startValue == endValue)
                {
                    throw new ArgumentOutOfRangeException(@"Starting value can not be equal ending value!");
                }

                progressBar.Maximum = (int)(endValue - startValue);

                _worker = new Worker(startValue, endValue, address);
                break;
            }

            default:
                throw new NotImplementedException(string.Format(@"Unsupported type: {0}", type));
            }

            progressLabel.Text = "Downloading...";

            _startTime = DateTime.Now;
            _worker.Start(backgroundWorker);
        }