C# 文件下载 : WebClient

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

最近更新了一个下载小工具，主要提升了下面几点：

1．在一些分公司的局域网中，连接不上外网

2．服务器上的文件更新后，下载到的还是更新前的文件

3．没有下载进度提示

4．不能终止下载

下面和大家分享一些心得。

鉴于各种复杂的网络环境，笔者决定采用不同的编程接口进行下载尝试，以增加程序的可用性。

这里仅介绍使用 WebClient 的方法，后续的文章会介绍其他的方法。博文中主要介绍思路和关键代码，完整的 demo 附在文末。

使用代理访问网络

很多公司的员工都是通过公司设置的代理上网的。通过代理上网主要是方便公司进行各种的管制，当然也能实现一些特殊的功能… 不过这会给我们的程序访问网络带来一些问题。

其实，WebClient 中的 API 已经很智能了，比如我们创建的 HttpWebRequest 对象，它自带一个 Proxy 属性。也就是说，WebHttpRequest 默认会使用找到的代理。这很棒，也能处理很多情况了。可是如果这个默认的代理需要验证域用户的身份信息，这时使用 WebHttpRequest 访问网络就可能失败。此时查看 Proxy. Credentials 属性，发现它是 null。

从 WebClient 的 API 中是可以取到系统默认的 Credentials 的，只是不太清楚为什么 Proxy.Credentials 属性默认没有设置为这个值。我们自己设置下就可以了。

request.Proxy.Credentials = CredentialCache.DefaultCredentials;

但实际的网络环境可能会更复杂，需要用户来指定联网的代理，并同时指定联网所需的 Credentials。写法如下：

myProxy = new WebProxy(“proxyAddress”);
myProxy.Credentials = new NetworkCredential(ProxyUserName, ProxyUserPasswd, DomainName);

克服缓存

缓存可谓无处不再，在服务器端 CDN 会有缓存，在客户端的代理层也会有缓存。所以经常出现的问题是：服务器上的文件明明更新了，还是会有一些客户下载到旧文件。我们先来处理客户端的缓存问题。

HttpWebRequest 的 CachePolicy.Level 属性就是设置缓存策略的，只是它的默认值是 BypassCache。我们把它改为 Reload 就行了:

request.CachePolicy = new System.Net.Cache.RequestCachePolicy(System.Net.Cache.RequestCacheLevel.Reload);

接下来是服务器端的缓存问题。

现在大家好像都在使用 CDN，可在使用中经常发现 CDN 端的缓存更新有问题。在网上查了查也没有什么好的解决办法，不过倒是有一个很好的 workaround，就是在请求中添加一个随机的字符串作为参数。

Random rdm = new Random();
string s = rdm.Next().ToString();
myUrl += "?" + s;

需要注意的是，关于缓存，一定要使用符合当前用例的策略，且不可搞一刀切。

更友好的下载过程

使用滚动条显示下载进度，显示实时的下载速度，允许用户取消下载：

aaarticlea/png;base64,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" alt="" />

下面是下载用的核心代码，我们把它分为计算下载百分比和计算当前下载速度分别介绍。

// 获得下载文件的长度
double contentLength = DownloadManager.GetContentLength(myHttpWebClient);
byte[] buffer = new byte[BufferSize];
long downloadedLength = ;
long currentTimeSpanDataLength = ;
int currentDataLength;
while ((currentDataLength = stream.Read(buffer, , BufferSize)) > && !this._cancelDownload)
{
fileStream.Write(buffer, , currentDataLength);
downloadedLength += (long)currentDataLength;
currentTimeSpanDataLength += (long)currentDataLength;
int intDownloadSpeed = ;
if (this._downloadStopWatch.ElapsedMilliseconds > )
{
double num5 = (double)currentTimeSpanDataLength / 1024.0;
double num6 = (double)this._downloadStopWatch.ElapsedMilliseconds / 1000.0;
double doubleDownloadSpeed = num5 / num6;
intDownloadSpeed = (int)Math.Round(doubleDownloadSpeed, );
this._downloadStopWatch.Reset();
this._downloadStopWatch.Start();
currentTimeSpanDataLength = ;
} double doubleDownloadPersent = 0.0;
if (contentLength > 0.0)
{
doubleDownloadPersent = (double)downloadedLength / contentLength;
}
}

在下载的过程中计算下载百分比

首先需要从 http 请求中获得要下载文件的长度，细节请参考本文所配 demo。

double contentLength = DownloadManager.GetContentLength(myHttpWebClient);

每从文件流中读取一次数据，我们知道读了多少个字节(currentDataLength)，累计下来就是当前已经下载了的文件长度。

downloadedLength += (long)currentDataLength;

然后做个除法就行了：

doubleDownloadPersent = (double)downloadedLength / contentLength;

计算实时的下载速度

对于当前的下载速度，我们计算过去的一段时间内下载下来的字节数。时间段可以使用 StopWatch 来获得，我选择的时间段要求大于 800 毫秒。

if (this._downloadStopWatch.ElapsedMilliseconds > )
{
/***********************************/
// 计算上一个时间段内的下载速度
double num5 = (double)currentTimeSpanDataLength / 1024.0;
double num6 = (double)this._downloadStopWatch.ElapsedMilliseconds / 1000.0;
double doubleDownloadSpeed = num5 / num6;
/***********************************/ intDownloadSpeed = (int)Math.Round(doubleDownloadSpeed, );
// 本次网速计算完成后重置时间计时器和数据计数器，开始下次的计算
this._downloadStopWatch.Reset();
this._downloadStopWatch.Start();
currentTimeSpanDataLength = ;
}

事实上每次计算下载速度的时间段长度是不顾定的，但这并不影响计算结果，我只要保证距离上次计算超过了 800 毫秒就行了。