Загрузка отслеживания прогресса HTTP

Ответ 1

это больше, чем год с момента публикации этого вопроса, но я думаю, что мой пост может быть полезен для кого-то.

У меня была та же проблема с показом прогресса, и он вел себя так, как вы описали. Поэтому я решил использовать HttpClient, который показывает правильность загрузки. Затем я столкнулся с интересной ошибкой - когда я запустил Fiddler, HttpClient начал демонстрировать свой прогресс загрузки неожиданным образом, как в WebClient/HttpWebRequest, поэтому я подумал, может быть, это была проблема того, почему WebClient не показывал загрузочные программы не правильно (я думаю, он был запущен). Поэтому я снова попытался с WebClient (без запуска скриптовых приложений), и все работает так, как должно, загружать прогресс имеет правильные значения. Я тестировал несколько ПК с win7 и XP, и во всех случаях прогресс показывался правильно.

Итак, я думаю, что такая программа, как Fiddler (возможно, не только скрипач), влияет на то, как WebClient и другие .net-классы показывают прогресс загрузки.

это обсуждение одобряет это:

HttpWebRequest не работает, кроме случаев, когда работает скрипач

Ответ 2

Вы можете использовать WebClient UploadFile для загрузки файла, а не для записи файла в виде потока файлов. Чтобы отслеживать процент полученных и загруженных данных, вы можете использовать UploadFileAsyn и подписаться на его события.

В приведенном ниже коде я использовал UploadFileAsyn для загрузки файлов синхронно, но он не должен быть синхронным, поскольку вы не размещаете экземпляр загрузчика.

class FileUploader : IDisposable
{
    private readonly WebClient _client;
    private readonly Uri _address;
    private readonly string _filePath;
    private bool _uploadCompleted;
    private bool _uploadStarted;
    private bool _status;

    public FileUploader(string address, string filePath)
    {
        _client = new WebClient();
        _address = new Uri(address);
        _filePath = filePath;
        _client.UploadProgressChanged += FileUploadProgressChanged;
        _client.UploadFileCompleted += FileUploadFileCompleted;
    }

    private void FileUploadFileCompleted(object sender, UploadFileCompletedEventArgs e)
    {
        _status = (e.Cancelled || e.Error == null) ? false : true;
        _uploadCompleted = true;
    }

    private void FileUploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
    {
        if(e.ProgressPercentage % 10 == 0)
        {
            //This writes the pecentage data uploaded and downloaded
            Console.WriteLine("Send: {0}, Received: {1}", e.BytesSent, e.BytesReceived);
            //You can have a delegate or a call back to update your UI about the percentage uploaded
            //If you don't have the condition (i.e e.ProgressPercentage % 10 == 0 )for the pecentage of the process 
            //the callback will slow you upload process down
        }
    }

    public bool Upload()
    {

        if (!_uploadStarted)
        {
            _uploadStarted = true;
            _client.UploadFileAsync(_address, _filePath);
        }
        while (!_uploadCompleted)
        {
            Thread.Sleep(1000);
        }
        return _status;
    }

    public void Dispose()
    {
        _client.Dispose();
    }
}

Код клиента:

            using (FileUploader uploader = new FileUploader("http://www.google.com", @"C:\test.txt"))
        {
            uploader.Upload();
        }

Вы можете зарегистрировать собственный обратный вызов (может быть делегатом) в обработчике события FileUploadProgressChanged для обновления вашего интерфейса WPF.

Процесс изменения загрузки изменился, вызывается чаще, если ваш обратный вызов для события делает IO, что замедляет процесс загрузки. Лучше всего иметь редкое обновление, например. следующее обновление кода обновляется только на 10%.

    private int _percentageDownloaded;

    private void FileUploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
    {
        if (e.ProgressPercentage % 10 == 0 && e.ProgressPercentage > _percentageDownloaded)
        {

            _percentageDownloaded = e.ProgressPercentage;
            //Any callback instead of printline
            Console.WriteLine("Send: {0} Received: {1}", e.BytesSent, e.BytesReceived);
        }
    }

Ответ 3

Мое предложение состоит в том, чтобы использовать новый класс HTTPClient (доступный в .NET 4.5). Он поддерживает прогресс.

Эта статья очень помогла мне в этом: http://www.strathweb.com/2012/06/drag-and-drop-files-to-wpf-application-and-asynchronously-upload-to-asp-net-web-api/

Мой код для загрузки файла:

    private void HttpSendProgress(object sender, HttpProgressEventArgs e)
    {
        HttpRequestMessage request = sender as HttpRequestMessage;
        Console.WriteLine(e.BytesTransferred);
    }

    private void Window_Loaded_1(object sender, RoutedEventArgs e)
    {
        ProgressMessageHandler progress = new ProgressMessageHandler();
        progress.HttpSendProgress += new EventHandler<HttpProgressEventArgs>(HttpSendProgress);

        HttpRequestMessage message = new HttpRequestMessage();
        StreamContent streamContent = new StreamContent(new FileStream("e:\\somefile.zip", FileMode.Open));

        message.Method = HttpMethod.Put;
        message.Content = streamContent;
        message.RequestUri = new Uri("{Here your link}");

        var client = HttpClientFactory.Create(progress);

        client.SendAsync(message).ContinueWith(task =>
        {
            if (task.Result.IsSuccessStatusCode)
            { 

            }
        });
    }

Ответ 4

Этот меня прослушивал хотя бы один день. Я начал с использования WebClient.UploadFileAsync, затем попробовал ProgressMessageHandler для HttpClient, а затем перевернул собственный HttpContent для API HttpClient. Ни один из этих подходов не работал (для меня).

Появляется HttpWebRequest, который находится внизу большинства (всех?) абстракций .NET Http, таких как WebClient и HttpClient, по умолчанию загружает поток запросов и ответов, который я подтвердил, посмотрев на него в ILSpy.

Как отмечали другие, вы можете заставить свой запрос использовать закодированное кодирование так или иначе, что эффективно отключает буферизацию потока запросов, но все же это не будет исправлять отчет о ходе.

Я обнаружил, что необходимо очистить поток запросов после каждого отправленного мной блока, чтобы точно отразить прогресс отправки, иначе ваши данные будут просто буферизоваться на один шаг дальше по конвейеру (возможно, где-то в NetworkStream или ОС, не проверял). Пример кода ниже работает для меня, а также выполняет минимальную работу по переводу обратно из HttpWebResponse в HttpResponseMessage (что вам может и не понадобиться, YMMV).

public async Task<HttpResponseMessage> UploadFileAsync( string uploadUrl, string absoluteFilePath, Action<int> progressPercentCallback )
    {
        var length = new FileInfo( absoluteFilePath ).Length;

        var request = new HttpWebRequest( new Uri(uploadUrl) ) {
            Method = "PUT",
            AllowWriteStreamBuffering = false,
            AllowReadStreamBuffering = false,
            ContentLength = length
        };

        const int chunkSize = 4096;
        var buffer = new byte[chunkSize];

        using (var req = await request.GetRequestStreamAsync())
        using (var readStream = File.OpenRead(absoluteFilePath))
        {
            progressPercentCallback(0);
            int read = 0;
            for (int i = 0; i < length; i += read)
            {
                read = await readStream.ReadAsync( buffer, 0, chunkSize );
                await req.WriteAsync( buffer, 0, read );
                await req.FlushAsync(); // flushing is required or else we jump to 100% very fast
                progressPercentCallback((int)(100.0 * i / length));
            }
            progressPercentCallback(100);
        }

        var response = (HttpWebResponse)await request.GetResponseAsync();
        var result = new HttpResponseMessage( response.StatusCode );
        result.Content = new StreamContent( response.GetResponseStream() );

        return result; 
    }

Ответ 5

По быстрому угадыванию вы запускаете этот код в потоке пользовательского интерфейса. Вам нужно запустить загрузку нового потока. В этот момент у вас есть 2 варианта. 1) Вы запускаете таймер в потоке пользовательского интерфейса и обновляете интерфейс. 2) Вы обновляете пользовательский интерфейс, используя Invoke (потому что вы не можете получить доступ к пользовательскому интерфейсу из другого потока) вызывает обновление интерфейса.

Ответ 6

В первом примере я думаю, что ваш индикатор выполнения показывает, как быстро вы записываете в поток из файла на диске, а не фактический уровень загрузки (вот почему все это происходит на 100% действительно быстро, а затем загружает chugs на *).

Возможно, я ошибаюсь ^^ и не имею опыта WPF, но я загрузил массивные файлы из Silverlight в WCF, а используемая там модель (как и вы) разбивает файл на блоки. Отправляйте каждый блок. Когда вы получаете ответ от сервера ( "блок 26 получил одобрение" ), обновите индикатор выполнения, как и в самом деле, вы не можете (или не должны) обновлять индикатор выполнения, если вы не знаете/что блок x сделал это, - и хороший способ узнать, что если сервер говорит, что получил его.

* Хотел бы я загрузить 400 Мб за 5 минут. Я буду принимать меня весь день...

Ответ 7

У меня была та же проблема. Я потратил много времени и решил проблему следующим образом: Антивирус AVAST. Когда я отключу его, моя программа отлично работает...