Apricot.Fetcher.Collect C# (CSharp) Method

        public int Collect()
        {
            Queue<Uri> uriQueue = new Queue<Uri>(this.subscriptionList);
            Queue<Task<IEnumerable<Entry>>> taskQueue = new Queue<Task<IEnumerable<Entry>>>();
            List<Entry> entryList = new List<Entry>();
            int successfulRow = 0;

            this.entryList.Clear();

            while (uriQueue.Count > 0 || taskQueue.Count > 0)
            {
                while (uriQueue.Count > 0 && taskQueue.Count < 2 * Environment.ProcessorCount)
                {
                    WebRequest webRequest = WebRequest.Create(uriQueue.Dequeue());
                    Task<IEnumerable<Entry>> task = new Task<IEnumerable<Entry>>(delegate (object state)
                    {
                        WebRequest request = (WebRequest)state;
                        WebResponse response = null;
                        Stream s = null;
                        BufferedStream bs = null;

                        try
                        {
                            response = request.GetResponse();
                            s = response.GetResponseStream();
                            bs = new BufferedStream(s);
                            s = null;

                            XmlDocument xmlDocument = new XmlDocument();

                            xmlDocument.Load(bs);
                            xmlDocument.Normalize();

                            if (xmlDocument.DocumentElement.NamespaceURI.Equals("http://www.w3.org/1999/02/22-rdf-syntax-ns#") && xmlDocument.DocumentElement.LocalName.Equals("RDF"))
                            {
                                return ParseRss10(xmlDocument.DocumentElement);
                            }
                            else if (xmlDocument.DocumentElement.Name.Equals("rss"))
                            {
                                foreach (XmlAttribute xmlAttribute in xmlDocument.DocumentElement.Attributes)
                                {
                                    if (xmlAttribute.Name.Equals("version"))
                                    {
                                        if (xmlAttribute.Value.Equals("2.0"))
                                        {
                                            return ParseRss20(xmlDocument.DocumentElement);
                                        }

                                        break;
                                    }
                                }
                            }
                            else if (xmlDocument.DocumentElement.NamespaceURI.Equals("http://www.w3.org/2005/Atom") && xmlDocument.DocumentElement.LocalName.Equals("feed"))
                            {
                                return ParseAtom10(xmlDocument.DocumentElement);
                            }
                        }
                        finally
                        {
                            if (bs != null)
                            {
                                bs.Close();
                            }

                            if (s != null)
                            {
                                s.Close();
                            }

                            if (response != null)
                            {
                                response.Close();
                            }
                        }

                        return Enumerable.Empty<Entry>();
                    }, webRequest, TaskCreationOptions.LongRunning);

                    if (this.timeout.HasValue)
                    {
                        webRequest.Timeout = this.timeout.Value;
                    }

                    if (this.userAgent != null)
                    {
                        HttpWebRequest httpWebRequest = webRequest as HttpWebRequest;

                        if (httpWebRequest != null)
                        {
                            httpWebRequest.UserAgent = this.userAgent;
                        }
                    }

                    taskQueue.Enqueue(task);
                    task.Start();
                }

                Task<IEnumerable<Entry>>[] tasks = taskQueue.ToArray();
                int index = Task<IEnumerable<Entry>>.WaitAny(tasks);

                taskQueue.Clear();

                for (int i = 0; i < tasks.Length; i++)
                {
                    if (index == i)
                    {
                        if (tasks[i].Exception == null)
                        {
                            this.entryList.AddRange(tasks[i].Result);
                        }
                    }
                    else
                    {
                        taskQueue.Enqueue(tasks[i]);
                    }
                }
            }

            foreach (System.Configuration.ConnectionStringSettings settings in System.Configuration.ConfigurationManager.ConnectionStrings)
            {
                DbProviderFactory factory = DbProviderFactories.GetFactory(settings.ProviderName);

                using (IDbConnection connection = factory.CreateConnection())
                {
                    connection.ConnectionString = settings.ConnectionString;
                    connection.Open();

                    this.entryList.ForEach(delegate (Entry entry)
                    {
                        if (entry.Resource != null)
                        {
                            string sql = null;

                            using (IDbCommand command = factory.CreateCommand())
                            {
                                command.Connection = connection;
                                command.CommandText = BuildSelectStatement(entry.Resource);

                                if ((int)command.ExecuteScalar() == 0)
                                {
                                    sql = BuildInsertStatement(entry);
                                }
                                else if (entry.Created < entry.Modified)
                                {
                                    sql = BuildUpdateStatement(entry);
                                }
                            }

                            if (sql != null)
                            {
                                using (IDbCommand c = factory.CreateCommand())
                                {
                                    c.Connection = connection;
                                    c.CommandText = sql;

                                    IDbTransaction transaction = connection.BeginTransaction(IsolationLevel.ReadCommitted);

                                    c.Transaction = transaction;

                                    try
                                    {
                                        successfulRow += c.ExecuteNonQuery();

                                        transaction.Commit();
                                    }
                                    catch
                                    {
                                        transaction.Rollback();
                                    }
                                }
                            }
                        }
                    });
                }
            }

            return successfulRow;
        }