<think>我们正在开发一个视频下载功能，使用C#和.NET环境。在实现断点续传时，遇到了HTTP 416错误（Requested Range Not Satisfiable）。这个错误通常发生在客户端请求的文件范围（例如，从某个字节开始）超出了服务器上文件的实际大小范围。根据引用内容，这个错误可能是因为我们尝试下载一个已经下载完成的文件，再次请求时，请求的范围（从已下载文件长度开始）已经超出了文件的实际大小（例如，文件总长度可能小于我们请求的起始位置）。
解决方案：
1. 在发起带Range头的请求之前，检查本地已下载文件的大小是否已经等于或超过服务器上文件的总大小。如果是，则跳过下载，直接使用本地文件。
2. 在请求之前，先发送一个HEAD请求获取文件的总大小，然后与本地文件大小比较。
步骤：
a. 在开始下载前，检查本地文件是否存在。
b. 如果存在，获取本地文件大小（fileLength）。
c. 发送HEAD请求到服务器，获取文件总大小（Content-Length）。
d. 比较本地文件大小和服务器文件大小：
- 如果本地文件大小等于服务器文件大小，说明文件已经下载完成，无需继续下载。
- 如果本地文件大小小于服务器文件大小，则从本地文件大小处开始断点续传。
- 如果本地文件大小大于服务器文件大小（通常不应该出现），则删除本地文件，重新下载。
但是，注意引用[1]中的代码片段，它直接使用了`fs_image.Length`作为已下载长度，然后设置`AddRange((int)fileLength_image)`。如果文件已经下载完成，那么`fileLength_image`就等于服务器文件大小，此时再设置`AddRange((int)fileLength_image)`就相当于请求从服务器文件大小的位置开始下载，而服务器文件的有效范围是0到Content-Length-1，所以请求的范围就是Content-Length到之后（但之后没有内容），因此服务器返回416错误。
因此，我们需要修改`DownloadVideoAsync`方法，在设置Range之前，先检查本地文件大小和服务器文件大小的关系。
具体实现：
1. 在`DownloadVideoAsync`方法中，首先检查本地文件是否存在，并获取其长度。
2. 发送HEAD请求（或GET请求，但使用HEAD可以避免下载整个文件）获取文件总大小。
3. 比较本地文件大小和服务器文件大小：
- 如果本地文件大小等于服务器文件大小，直接返回，无需下载。
- 如果本地文件大小大于服务器文件大小，删除本地文件，然后重新下载（或者也可以考虑重命名，然后重新下载，但通常删除即可）。
- 如果本地文件大小小于服务器文件大小，则设置Range头从本地文件大小开始下载。
注意：在实现中，我们可能需要在`IVideoService`中修改`DownloadVideoAsync`方法，使其能够支持断点续传，并且正确处理416错误。
另外，引用[3]解释了416错误的原因：请求的范围无法满足，因为被访问的资源不覆盖这个字节范围。
因此，我们可以在`DownloadVideoAsync`方法中实现上述逻辑。
代码调整示例（伪代码）：
```csharp
public async Task DownloadVideoAsync(string videoUrl, string localFilePath, IProgress<double> progress, CancellationToken cancellationToken)
{
// 检查本地文件
long existingBytes = 0;
if (File.Exists(localFilePath))
{
var fileInfo = new FileInfo(localFilePath);
existingBytes = fileInfo.Length;
}
// 创建请求获取文件总大小
long totalBytes = await GetContentLengthAsync(videoUrl, cancellationToken);
// 如果本地文件大小等于或超过总大小，则直接返回（已经下载完成）
if (existingBytes >= totalBytes)
{
progress?.Report(1.0); // 报告100%进度
return;
}
// 如果本地文件大小大于总大小（异常情况），删除文件
if (existingBytes > totalBytes)
{
File.Delete(localFilePath);
existingBytes = 0;
}
// 创建HttpWebRequest
var request = (HttpWebRequest)WebRequest.Create(videoUrl);
request.AddRange(existingBytes); // 设置Range头
using (var response = (HttpWebResponse)await request.GetResponseAsync())
{
// 检查响应状态
if (response.StatusCode == HttpStatusCode.PartialContent) // 206
{
// 断点续传
using (var responseStream = response.GetResponseStream())
using (var fileStream = new FileStream(localFilePath, FileMode.Append, FileAccess.Write))
{
var buffer = new byte[8192];
int bytesRead;
long bytesReceived = existingBytes;
long totalBytesToReceive = totalBytes; // 总大小
while ((bytesRead = await responseStream.ReadAsync(buffer, 0, buffer.Length, cancellationToken)) > 0)
{
await fileStream.WriteAsync(buffer, 0, bytesRead, cancellationToken);
bytesReceived += bytesRead;
double progressPercentage = (double)bytesReceived / totalBytesToReceive;
progress?.Report(progressPercentage);
}
}
}
else if (response.StatusCode == HttpStatusCode.OK) // 200
{
// 服务器不支持断点续传，重新下载
using (var responseStream = response.GetResponseStream())
using (var fileStream = new FileStream(localFilePath, FileMode.Create, FileAccess.Write))
{
// 正常下载...
}
}
else
{
// 处理其他状态码
throw new Exception($"Unexpected status code: {response.StatusCode}");
}
}
}
private async Task<long> GetContentLengthAsync(string url, CancellationToken cancellationToken)
{
var request = (HttpWebRequest)WebRequest.Create(url);
request.Method = "HEAD";
using (var response = (HttpWebResponse)await request.GetResponseAsync())
{
if (response.StatusCode == HttpStatusCode.OK)
{
return response.ContentLength;
}
else
{
throw new Exception($"Could not retrieve file size. Status code: {response.StatusCode}");
}
}
}
```
注意：上面的代码中，我们首先通过HEAD请求获取文件大小。但是，有些服务器可能不支持HEAD请求，或者返回的Content-Length不可靠（例如动态生成的内容）。因此，我们需要考虑异常情况。
另外，如果服务器不支持断点续传（即不支持Range请求），那么我们在请求中设置了Range头，服务器可能会忽略Range头并返回整个文件（200 OK），或者返回416错误（如果我们请求的范围无效）。在上面的代码中，我们处理了206（部分内容）和200（整个文件）的情况。
但是，如果服务器返回416错误，我们可以在catch块中处理，比如删除本地文件然后重试（不设置Range头）？或者，我们可以先检查是否本地文件已经完整（通过比较本地文件大小和服务器返回的Content-Length）？不过，我们已经在开始下载前通过HEAD请求获取了文件大小，所以理论上不会出现416错误。但是，如果在下载过程中服务器上的文件发生了变化（比如被更新），那么可能会出现416错误。因此，更健壮的做法是捕获416错误，然后删除本地文件重新下载。
改进：在捕获到WebException且状态为416时，删除本地文件并重新开始下载（不设置Range头）。
但是，由于我们已经在开始下载前通过HEAD请求获取了文件大小，并进行了比较，所以正常情况下不会出现416错误。所以，我们可以在代码中不处理416错误，因为我们已经通过前置检查避免了416错误。如果仍然出现416错误，可能是由于服务器上的文件发生了变化（在HEAD请求之后），那么我们可以考虑重新获取文件大小，然后重新开始。
然而，为了代码的健壮性，我们可以这样做：
1. 在下载过程中，如果捕获到416错误，则删除本地文件，然后重新调用DownloadVideoAsync（注意避免递归过深，可以设置重试次数）。
2. 或者，在416错误发生时，重新获取文件大小，然后调整Range头。
由于416错误相对少见，我们可以选择第一种简单方式：删除本地文件，然后重新下载。
代码调整：
```csharp
public async Task DownloadVideoAsync(string videoUrl, string localFilePath, IProgress<double> progress, CancellationToken cancellationToken)
{
int retryCount = 0;
const int maxRetry = 2;
while (retryCount < maxRetry)
{
try
{
// 原有的下载逻辑（包括前置检查）
// ... 省略前置检查代码 ...
// 创建请求并设置Range头
var request = (HttpWebRequest)WebRequest.Create(videoUrl);
request.AddRange(existingBytes);
using (var response = (HttpWebResponse)await request.GetResponseAsync())
{
// 处理响应...
}
break; // 成功则跳出循环
}
catch (WebException ex) when (ex.Response is HttpWebResponse response && response.StatusCode == (HttpStatusCode)416)
{
// 416错误处理
retryCount++;
if (retryCount >= maxRetry)
throw;
// 删除本地文件，然后重试（existingBytes将变为0）
if (File.Exists(localFilePath))
File.Delete(localFilePath);
}
}
}
```
但是，这样处理可能会陷入循环（如果服务器一直返回416），所以我们设置重试次数（比如2次）。
总结解决方案：
1. 在设置Range头之前，通过HEAD请求获取服务器文件大小，并与本地文件大小比较，避免无效的Range请求。
2. 捕获416错误，并重试（删除本地文件后重新下载）。
这样应该能解决HTTP 416错误的问题。
注意：在实现中，我们还需要考虑网络不稳定、服务器文件变化等情况，但上述方案已经可以解决用户遇到的416错误问题。
另外，在用户提供的`DowmLoadViewModel`中，`StartDownload`方法调用了`_videoService.DownloadVideoAsync`，我们修改了`DownloadVideoAsync`的实现，但接口`IVideoService`需要相应地更新（增加参数`IProgress<double>`和`CancellationToken`）。如果接口中还没有定义这些参数，需要修改接口定义。
例如：
```csharp
public interface IVideoService
{
Task DownloadVideoAsync(string url, string localPath, IProgress<double> progress, CancellationToken cancellationToken);
}
```
这样，ViewModel中的调用方式不变。
最后，在ViewModel中，我们使用`CancellationTokenSource`来支持取消操作，这已经实现。
因此，我们通过修改`DownloadVideoAsync`方法的实现，加入前置检查以及416错误的异常处理，可以解决416错误问题。
希望这个解决方案能帮助用户解决问题。</think>### 解决 HTTP 416 范围请求错误的完整方案
在视频下载功能中遇到 HTTP 416 (Requested Range Not Satisfiable) 错误，通常是由于断点续传时请求的文件范围超出服务器文件实际大小导致的。以下是针对 C# `VideoService.DownloadVideoAsync` 方法的完整解决方案：
#### 核心问题分析
当本地已下载文件大小 ≥ 服务器文件总大小时，再发送带 `Range` 头的请求会触发 416 错误：
$$ \text{If } \text{localSize} \geq \text{remoteSize} \implies \text{HTTP 416} $$
#### 解决方案代码
```csharp
public async Task DownloadVideoAsync(
string url,
string localPath,
IProgress<double> progress,
CancellationToken cancellationToken)
{
long localSize = 0;
long remoteSize = await GetRemoteFileSize(url);
// 检查本地文件状态
if (File.Exists(localPath))
{
localSize = new FileInfo(localPath).Length;
// 情况1：文件已完整下载
if (localSize == remoteSize)
{
progress?.Report(1.0); // 报告100%进度
return; // 直接返回不重复下载[^1]
}
// 情况2：本地文件异常（大于服务器文件）
if (localSize > remoteSize)
{
File.Delete(localPath);
localSize = 0;
}
}
using (var client = new HttpClient())
{
// 设置范围请求头（仅当需要续传时）
if (localSize > 0 && localSize < remoteSize)
{
client.DefaultRequestHeaders.Range =
new RangeHeaderValue(localSize, null);
}
using (var response = await client.GetAsync(
url,
HttpCompletionOption.ResponseHeadersRead,
cancellationToken))
{
// 处理416错误（额外防护）
if (response.StatusCode == HttpStatusCode.RequestedRangeNotSatisfiable)
{
File.Delete(localPath);
await DownloadVideoAsync(url, localPath, progress, cancellationToken);
return;
}
response.EnsureSuccessStatusCode();
using (var remoteStream = await response.Content.ReadAsStreamAsync())
using (var localStream = File.Open(localPath, FileMode.Append))
{
var buffer = new byte[8192];
long totalRead = localSize;
int bytesRead;
while ((bytesRead = await remoteStream.ReadAsync(
buffer, 0, buffer.Length, cancellationToken)) > 0)
{
await localStream.WriteAsync(buffer, 0, bytesRead, cancellationToken);
totalRead += bytesRead;
// 更新进度（分母用服务器文件大小）
progress?.Report((double)totalRead / remoteSize);
}
}
}
}
}
// 获取服务器文件大小
private async Task<long> GetRemoteFileSize(string url)
{
using (var client = new HttpClient())
using (var response = await client.SendAsync(
new HttpRequestMessage(HttpMethod.Head, url)))
{
response.EnsureSuccessStatusCode();
return response.Content.Headers.ContentLength ?? 0;
}
}
```
#### 关键改进点
1. **前置文件校验**（解决416核心问题）
- 通过 `HEAD` 请求获取服务器文件大小[^3]
- 本地文件 ≥ 服务器文件时直接跳过下载
- 本地文件 > 服务器文件时删除异常文件
2. **智能范围请求**
- 仅当 $0 < \text{localSize} < \text{remoteSize}$ 时添加 `Range` 头
- 避免无效范围请求：`Range: bytes=${localSize}-`
3. **错误恢复机制**
```csharp
if (response.StatusCode == HttpStatusCode.RequestedRangeNotSatisfiable)
{
File.Delete(localPath); // 删除异常文件
await DownloadVideoAsync(...); // 重启下载
}
```
4. **进度计算优化**
- 分母始终使用服务器文件大小：$\frac{\text{totalRead}}{\text{remoteSize}}$
- 避免本地文件异常导致的进度计算错误
#### 使用示例
```csharp
// 在ViewModel中调用
await _videoService.DownloadVideoAsync(
"https://example.com/video.mp4",
"localVideo.mp4",
new Progress<double>(p => DownloadProgress = p),
_downloadCts.Token);
```
#### 预防416错误的最佳实践
1. **实现下载状态持久化**
```csharp
// 记录下载元数据
class DownloadState {
public string Url { get; set; }
public long RemoteSize { get; set; }
public string LocalPath { get; set; }
}
```
2. **增加文件校验**
```csharp
// 下载完成后验证文件完整性
if (new FileInfo(localPath).Length != remoteSize)
{
throw new InvalidDataException("文件校验失败");
}
```
3. **服务器兼容处理**
- 某些服务器（如Nginx）需配置 `max_ranges` 参数
- CDN服务需开启Range请求支持
> **关键点**：416错误本质是客户端请求范围与服务器资源不匹配造成的。通过精确管理本地文件状态和服务器资源比对，可彻底避免此问题[^1][^3]。
本文探讨了为何大部分程序员难以转型成为架构师的原因。文章分析了架构师所需具备的技术视野、经验积累及团队协作能力等关键因素。
扫一扫
658
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
