我的应用程序需要将大量的网页下载到内存中进行进一步的解析和处理。那么最快的方式是什么？我的当前方法（如下所示）似乎太慢了，有时还会导致超时。
for (int i = 1; i<=pages; i++)
{
string page_specific_link = baseurl + "&page=" + i.ToString();
try
{
WebClient client = new WebClient();
var pagesource = client.DownloadString(page_specific_link);
client.Dispose();
sourcelist.Add(pagesource);
}
catch (Exception)
{
}
}
// Create queue of WebClient instances
BlockingCollection<WebClient> ClientQueue = new BlockingCollection<WebClient>();
// Initialize queue with some number of WebClient instances
// now process urls
foreach (var url in urls_to_download)
{
var worker = ClientQueue.Take();
worker.DownloadStringAsync(url, ...);
}
WebClient MyWebClient = new WebClient();
foreach (var url in urls_to_download)
{
MyWebClient.DownloadString(url);
}
---------------
foreach (var url in urls_to_download)
{
WebClient MyWebClient = new WebClient();
MyWebClient.DownloadString(url);
}
WebClient实例，用于所有请求。第二种方法为每个请求分配一个WebClient。两者之间的差异是巨大的。WebClient使用了大量系统资源，在相对较短的时间内分配数千个WebClient将影响性能。相信我...我曾经遇到过这种情况。最好只分配10或20个WebClient（尽可能多地满足并发处理的需求），而不是为每个请求分配一个WebClient。Sleep循环不太令人满意。他基本上以与我相同的方式限制线程数量。他只是使用更多的代码来实现。 - Jim Mischel为什么不直接使用网络爬虫框架呢？它可以帮你处理所有的事情，例如多线程、HTTP请求、链接解析、调度、礼貌等。
Abot（https://code.google.com/p/abot/）可以为您处理所有这些内容，并且是用C#编写的。
除了@David的完全有效的回答外，我想补充一下他方法的略微简洁的“版本”。
var pages = new List<string> { "http://bing.com", "http://stackoverflow.com" };
var sources = new BlockingCollection<string>();
Parallel.ForEach(pages, x =>
{
using(var client = new WebClient())
{
var pagesource = client.DownloadString(x);
sources.Add(pagesource);
}
});
另一种方法是使用async：
static IEnumerable<string> GetSources(List<string> pages)
{
var sources = new BlockingCollection<string>();
var latch = new CountdownEvent(pages.Count);
foreach (var p in pages)
{
using (var wc = new WebClient())
{
wc.DownloadStringCompleted += (x, e) =>
{
sources.Add(e.Result);
latch.Signal();
};
wc.DownloadStringAsync(new Uri(p));
}
}
latch.Wait();
return sources;
}
你应该使用并行编程来实现这个目的。
有很多方法可以达到你想要的效果；最简单的方法可能是像这样：
var pageList = new List<string>();
for (int i = 1; i <= pages; i++)
{
pageList.Add(baseurl + "&page=" + i.ToString());
}
// pageList is a list of urls
Parallel.ForEach<string>(pageList, (page) =>
{
try
{
WebClient client = new WebClient();
var pagesource = client.DownloadString(page);
client.Dispose();
lock (sourcelist)
sourcelist.Add(pagesource);
}
catch (Exception) {}
});
sourcelist。这样做很有可能会导致列表损坏。 - casperOneAsParallel，foreach 也不会并行运行。您必须使用 Parallel.ForEach。 - Daniel我正在使用活动线程计数和任意限制：
private static volatile int activeThreads = 0;
public static void RecordData()
{
var nbThreads = 10;
var source = db.ListOfUrls; // Thousands urls
var iterations = source.Length / groupSize;
for (int i = 0; i < iterations; i++)
{
var subList = source.Skip(groupSize* i).Take(groupSize);
Parallel.ForEach(subList, (item) => RecordUri(item));
//I want to wait here until process further data to avoid overload
while (activeThreads > 30) Thread.Sleep(100);
}
}
private static async Task RecordUri(Uri uri)
{
using (WebClient wc = new WebClient())
{
Interlocked.Increment(ref activeThreads);
wc.DownloadStringCompleted += (sender, e) => Interlocked.Decrement(ref iterationsCount);
var jsonData = "";
RootObject root;
jsonData = await wc.DownloadStringTaskAsync(uri);
var root = JsonConvert.DeserializeObject<RootObject>(jsonData);
RecordData(root)
}
}
我曾经遇到过类似的情况，这是我解决问题的方法
using System;
using System.Threading;
using System.Collections.Generic;
using System.Net;
using System.IO;
namespace WebClientApp
{
class MainClassApp
{
private static int requests = 0;
private static object requests_lock = new object();
public static void Main() {
List<string> urls = new List<string> { "http://www.google.com", "http://www.slashdot.org"};
foreach(var url in urls) {
ThreadPool.QueueUserWorkItem(GetUrl, url);
}
int cur_req = 0;
while(cur_req<urls.Count) {
lock(requests_lock) {
cur_req = requests;
}
Thread.Sleep(1000);
}
Console.WriteLine("Done");
}
private static void GetUrl(Object the_url) {
string url = (string)the_url;
WebClient client = new WebClient();
Stream data = client.OpenRead (url);
StreamReader reader = new StreamReader(data);
string html = reader.ReadToEnd ();
/// Do something with html
Console.WriteLine(html);
lock(requests_lock) {
//Maybe you could add here the HTML to SourceList
requests++;
}
}
}
你应该考虑使用并行编程，因为慢速是由于你的软件正在等待I/O操作，而为什么不在一个线程等待I/O时启动另一个线程呢。
虽然其他答案都是完全有效的，但它们（在撰写本文时）都忽略了非常重要的一点：通过网络调用IO bound，让线程等待这样的操作会对系统资源造成压力，并影响系统资源。
你真正想做的是利用WebClient类上的异步方法（如一些人指出的那样），以及任务并行库处理基于事件的异步模式的能力。
首先，您将获取要下载的URL：
IEnumerable<Uri> urls = pages.Select(i => new Uri(baseurl +
"&page=" + i.ToString(CultureInfo.InvariantCulture)));
TaskCompletionSource<T>类}}来异步处理调用（这不会占用一个线程）：IEnumerable<Task<Tuple<Uri, string>> tasks = urls.Select(url => {
// Create the task completion source.
var tcs = new TaskCompletionSource<Tuple<Uri, string>>();
// The web client.
var wc = new WebClient();
// Attach to the DownloadStringCompleted event.
client.DownloadStringCompleted += (s, e) => {
// Dispose of the client when done.
using (wc)
{
// If there is an error, set it.
if (e.Error != null)
{
tcs.SetException(e.Error);
}
// Otherwise, set cancelled if cancelled.
else if (e.Cancelled)
{
tcs.SetCanceled();
}
else
{
// Set the result.
tcs.SetResult(new Tuple<string, string>(url, e.Result));
}
}
};
// Start the process asynchronously, don't burn a thread.
wc.DownloadStringAsync(url);
// Return the task.
return tcs.Task;
});
IEnumerable<T>，你可以将其转换为数组，并使用Task.WaitAll等待所有结果：// Materialize the tasks.
Task<Tuple<Uri, string>> materializedTasks = tasks.ToArray();
// Wait for all to complete.
Task.WaitAll(materializedTasks);
然后，您只需在Task<T>实例上使用{{link1：Result属性}}即可获取url和内容的对：
// Cycle through each of the results.
foreach (Tuple<Uri, string> pair in materializedTasks.Select(t => t.Result))
{
// pair.Item1 will contain the Uri.
// pair.Item2 will contain the content.
}
Task<T>应该像管道一样使用，当您完成工作单元时，让它继续到下一个工作单元，而不是等待所有项目完成（如果它们可以以异步方式完成）。Uri。 - casperOne>。例如：IEnumerable<Task<Tuple<Uri, string>> tasks 这段代码无法编译，而且某些类型是错误的。 - Shiva
WebClient类最终将使用HttpWebRequest/HttpWebResponse类，这些类使用ServicePointManager类。默认情况下，ServicePointManager将限制特定域的大多数下载为每次两个（根据HTTP 1.1规范的建议）。 - casperOneServicePointManager，我只是将其与在命令行上发出一堆wget ... &进行了比较。我不知道 HTTP 1.1 推荐，但在这个时代似乎太少了。在我看来，OP 可能会想要覆盖它。 - Miserable Variable