Поток.CopyToAsync с отчетностью о ходе работы-прогресс сообщается даже после завершения копирования
Я строить простые консольные приложения, которые загружают файлы из интернета.
Потому что у меня были проблемы с WebClient я решил написать свое приложение с помощью HttpClient.
в основном я делаю запрос на чтение заголовков, а затем использую ReadAsStreamAsync Я получаю поток, который я копирую на локальный файл с помощью CopyToAsync.
Я нашел метод расширения для потока, который поддерживает IProgress:
public static class StreamExtensions
{
public static async Task CopyToAsync(this Stream source, Stream destination, IProgress<long> progress, CancellationToken cancellationToken = default(CancellationToken), int bufferSize = 0x1000)
{
var buffer = new byte[bufferSize];
int bytesRead;
long totalRead = 0;
while ((bytesRead = await source.ReadAsync(buffer, 0, buffer.Length, cancellationToken)) > 0)
{
await destination.WriteAsync(buffer, 0, bytesRead, cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
totalRead += bytesRead;
//Thread.Sleep(10);
progress.Report(totalRead);
}
}
}
мое приложение работает, но я получаю неверная информация о ходе работы.
Например, при загрузке 2 файлов я вижу это в окне вывода:
file1.tmp 60.95%
file2.tmp 98.09%
file1.tmp 60.98%
file2.tmp 98.21%
file2.tmp 98.17%
file2.tmp 98.25%
file1.tmp 61.02%
file2.tmp 98.41%
file2.tmp downloaded
file2.tmp 98.29%
file2.tmp 98.37%
file1.tmp 61.06%
file2.tmp 89.27%
file2.tmp 89.31%
file2.tmp 98.33%
file2.tmp 98.45%
file2.tmp 98.48%
file1.tmp 61.10%
file1.tmp 61.14%
file2.tmp 98.52%
file1.tmp 61.22%
file2.tmp 98.60%
file2.tmp 98.56%
file1.tmp 61.30%
file2.tmp 98.88%
file2.tmp 90.44%
file1.tmp 61.53%
file2.tmp 98.72%
file1.tmp 61.41%
file1.tmp 61.73%
file2.tmp 98.80%
file1.tmp 61.26%
file1.tmp 61.49%
file1.tmp 61.57%
file1.tmp 61.69%
...
file1.tmp 99.31%
file1.tmp 98.84%
file1.tmp 98.80%
file1.tmp 99.04%
file1.tmp 99.43%
file1.tmp 99.12%
file1.tmp 99.00%
file1.tmp downloaded
file1.tmp 100.00%
file1.tmp 98.73%
file1.tmp 98.88%
file1.tmp 99.47%
file1.tmp 99.98%
file1.tmp 99.90%
file1.tmp 98.96%
file1.tmp 99.78%
file1.tmp 99.99%
file1.tmp 99.74%
file1.tmp 99.59%
file1.tmp 99.94%
file1.tmp 98.49%
file1.tmp 98.53%
ALL FILES DOWNLOADED
file1.tmp 99.55%
file1.tmp 98.41%
file1.tmp 99.62%
file1.tmp 98.34%
file1.tmp 99.66%
file1.tmp 98.69%
file1.tmp 98.37%
как вы можете видеть, я получил информацию о том, что file2 загружен, но я все еще получаю отчет о ходе работы от CopyToAsync, то же самое с file1.
из-за этого я иногда получаю этот странный консольный вывод:
в идеале я хотел бы быть уверен, чем когда я звоню:
await streamToReadFrom.CopyToAsync(streamToWriteTo, progress, source.Token,0x2000);
Debug.WriteLine(filename+" downloaded");
после того, как я получу эту отладку информация о прогрессе не сообщается (файл загружен). Я так и думал!--7--> решат мою проблему, но это не так.
как я могу это исправить? В качестве временного решения я добавляю поток.Сон CopyToAsync как раз перед тем, как я сообщу о прогрессе.
ниже мой текущий код:
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
namespace AsyncDownloadTest
{
class Program
{
private const string LocalPath = @"D:TEMP";
static void Main()
{
try
{
var filesToDownlad = new List<Tuple<string, string>>
{
new Tuple<string, string>("file1.tmp", "http://ipv4.download.thinkbroadband.com/10MB.zip"),
new Tuple<string, string>("file2.tmp", "http://ipv4.download.thinkbroadband.com/10MB.zip")
};
_consolePosition = -1;
Console.CursorVisible = false;
Parallel.ForEach(filesToDownlad, new ParallelOptions { MaxDegreeOfParallelism = 4 }, doc =>
{
DownloadFile(doc.Item2,doc.Item1).Wait();
});
Debug.WriteLine("ALL FILES DOWNLOADED");
Console.CursorVisible = true;
}
catch (Exception e)
{
Console.WriteLine(e);
Console.ReadLine();
}
}
private static readonly object ConsoleLock = new object();
private static int _consolePosition;
static readonly CancellationTokenSource source = new CancellationTokenSource();
private static async Task DownloadFile(string url, string filename)
{
int currenctLineNumber = 0;
int currectProgress = 0;
try
{
lock (ConsoleLock)
{
_consolePosition++;
currenctLineNumber = _consolePosition;
}
long fileSize = -1;
IProgress<long> progress = new Progress<long>(value =>
{
decimal tmp = (decimal)(value * 100) / fileSize;
if (tmp != currectProgress && tmp > currectProgress)
{
lock (ConsoleLock)
{
currectProgress = (int)tmp;
Console.CursorTop = currenctLineNumber;
Console.CursorLeft = 0;
Console.Write("{0,10} - {2,11} - {1,6:N2}%", filename, tmp, "DOWNLOADING");
}
Debug.WriteLine("{1} {0:N2}%", tmp, filename);
}
});
using (HttpClient client = new HttpClient())
{
using (HttpResponseMessage response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, source.Token))
{
response.EnsureSuccessStatusCode();
if (response.Content.Headers.ContentLength.HasValue) fileSize = response.Content.Headers.ContentLength.Value;
if (response.Content.Headers.ContentDisposition != null)
{
var tmp = response.Content.Headers.ContentDisposition.FileName.Replace(""", "");
Debug.WriteLine("Real name: {0}",tmp);
}
using (Stream streamToReadFrom = await response.Content.ReadAsStreamAsync())
{
using (Stream streamToWriteTo = File.Open(Path.Combine(LocalPath, filename), FileMode.Create, FileAccess.Write))
{
await streamToReadFrom.CopyToAsync(streamToWriteTo, progress, source.Token,0x2000);
Debug.WriteLine(filename+" downloaded");
lock (ConsoleLock)
{
Console.CursorTop = currenctLineNumber;
Console.CursorLeft = 0;
var oldColor = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Green;
Console.Write("{0,10} - {2,11} - {1,6:N2}%", filename, 100, "SUCCESS");
Console.ForegroundColor = oldColor;
}
}
}
}
}
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
lock (ConsoleLock)
{
Console.CursorTop = currenctLineNumber;
Console.CursorLeft = 0;
var oldColor = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Red;
Console.Write("{0,10} - {2,11} - {1,6:N2}%", filename, currectProgress, "ERROR");
Console.ForegroundColor = oldColor;
}
}
}
}
public static class StreamExtensions
{
public static async Task CopyToAsync(this Stream source, Stream destination, IProgress<long> progress, CancellationToken cancellationToken = default(CancellationToken), int bufferSize = 0x1000)
{
var buffer = new byte[bufferSize];
int bytesRead;
long totalRead = 0;
while ((bytesRead = await source.ReadAsync(buffer, 0, buffer.Length, cancellationToken)) > 0)
{
await destination.WriteAsync(buffer, 0, bytesRead, cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
totalRead += bytesRead;
Thread.Sleep(10);
progress.Report(totalRead);
}
}
}
}
2 ответов
ваша проблема на самом деле вот:
new Progress<long>
на Progress<T> класс всегда вызывает обратные вызовы в SynchronizationContext - который в этом случае является пулом потоков SynchronizationContext. Это означает, что когда код отчета о ходе выполнения вызывает Report, это просто очередь обратного вызова в пул потоков. Таким образом, можно увидеть, что они вышли из строя (или все еще приходят немного после завершения загрузки).
чтобы исправить это, вы можете создать свой собственные реализации IProgress<T>:
//C#6.0
public sealed class SynchronousProgress<T> : IProgress<T>
{
private readonly Action<T> _callback;
public SynchronousProgress(Action<T> callback) { _callback = callback; }
void IProgress<T>.Report(T data) => _callback(data);
}
//older version
public sealed class SynchronousProgress<T> : IProgress<T>
{
private readonly Action<T> _callback;
public SynchronousProgress(Action<T> callback)
{
_callback = callback;
}
void IProgress<T>.Report(T data)
{
_callback(data);
}
}
затем замените строку
IProgress<long> progress = new Progress<long>(value =>
С
IProgress<long> progress = new SynchronousProgress<long>(value =>
ОП попросил показать, как сделать его программу с потоком данных TPL в комментариях. На самом деле это довольно простое преобразование. Сначала добавьте ссылку на пакет NuGet