Предыстория

Есть у меня маленький и уютный pet-project, который позволяет качать файлы из интернета. Файлы при этом группируются и пользователю отображается не каждый файл, а некоторая группировка. И весь процесс скачивания (и отображение этого процесса) сильно зависел от данных. Данные при этом получались на лету, т.е. пользователь запускает на скачивание и нет никакой информации, сколько придётся качать в реальности.

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

И тут появляется пользователь с логичной проблемой — на большой группировке непонятно, почему прогресс еле ползёт — много файлов надо скачать или низкая скорость? Как я упоминал выше — количество файлов заранее неизвестно. Поэтому, я принял решение добавить счетчик скорости.

Анализ

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

uTorrent	DownloadMaster

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

Итак, нам нужна простая цифра вида 10 MB/s или что-то подобное. Как же нам её посчитать?

Теория и практика

Существующая реализация скачивания использовала HttpWebRequest и я решил не переделывать само скачивание — не стоит трогать работающий механизм.

Итак, начальная реализация без какого-либо подсчета:

            var request = WebRequest.Create(uri);             var response = await request.GetResponseAsync();             using (var ms = new MemoryStream())             {                 await response.GetResponseStream().CopyToAsync(ms);                 return ms.ToArray();             }

На уровне такого API реагировать можно только на полное скачивание файла, для небольших групп (или даже для одного файла) скорость фактически не посчитать. Идём за исходниками CopyToAsync, копипастим оттуда простую логику:

            byte[] buffer = new byte[bufferSize];             int bytesRead;             while ((bytesRead = await ReadAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(false)) != 0)             {                 await destination.WriteAsync(buffer, 0, bytesRead, cancellationToken).ConfigureAwait(false);             }

Теперь мы можем реагировать на каждый буфер, отданный нам по сети.

Итак, во первых, что мы делаем вместо коробочного CopyToAsync:

        public static async Task<byte[]> GetBytesAsync(this Stream from)         {             using (var memory = new MemoryStream())             {                 byte[] buffer = new byte[81920];                 int bytesRead;                 while ((bytesRead = await from.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false)) != 0)                 {                     await memory.WriteAsync(buffer, 0, bytesRead).ConfigureAwait(false);                     NetworkSpeed.AddInfo(bytesRead);                 }                 return memory.ToArray();             }         }

Единственное, что реально добавлено — NetworkSpeed.AddInfo. И единственное, что мы передаем — количество скачанных байт.

Сам код для скачивания выглядит в итоге так:

            var request = WebRequest.Create(uri);             var response = await request.GetResponseAsync();             var array = await response.GetResponseStream().GetBytesAsync();

            var client = new WebClient();             var lastRecorded = 0L;             client.DownloadProgressChanged += (sender, eventArgs) =>             {                 NetworkSpeed.AddInfo(eventArgs.BytesReceived - lastRecorded);                 lastRecorded = eventArgs.BytesReceived;             };             var array = await client.DownloadDataTaskAsync(uri);

            var httpClient = new HttpClient();             var content = await httpClient.GetStreamAsync(uri);             var array = await content.GetBytesAsync();

Хорошо, половина задачи решена — мы знаем, сколько мы скачали. Переходим к скорости.

Согласно википедии :

Скорость передачи данных — объём данных, передаваемых за единицу времени.

Первый наивный подход

У нас есть объём. Время можно взять буквально запуска и получать разницу с DateTime.Now. Берем и делим?
Для консольных утилит типа curl такое возможно и имеет смысл.
Но если ваше приложение чуть сложнее, то буквально кнопка "пауза" резко усложнит вам жизнь.

Немного про паузу
Может я очень наивен, а может вопрос действительно не так прост — но пауза меня заставляет задумываться постоянно. Пауза при скачивании может вести себя минимум тремя способами:

• прерывать закачку файлов, начинать заново после
• просто не качать файл дальше, надеяться что сервер даст продолжить после
• докачивать уже начатые файлы, не качать новые, качать новые после

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

• нельзя нормально посчитать, какой была средняя скорость, просто взяв объем на время
• пауза может иметь внешние причины, которые поменяют скорость и канал (переподключение к сети провайдера, переключение на VPN, завершение uTorrent-a занявшего весь канал), что приведёт к изменению реальной скорости
  Фактически, пауза разделяет любые показатели на до и после неё. Это не влияет особо на код ниже, просто минутка забавной информации на подумать.

Второй наивный подход

Добавим таймер. Таймер каждый период времени будет брать всю свежую информацию о скачанном объеме и пересчитывать показатель скорости. А если таймер поставить в секунду, то вся полученная за эту секунду информация о скачанном объеме и будет равна скорости за эту секунду:

    public class NetworkSpeed     {         public static double TotalSpeed { get { return totalSpeed; } }          private static double totalSpeed = 0;          private const uint TimerInterval = 1000;          private static Timer speedTimer = new Timer(state =>         {             var now = 0L;             while (ReceivedStorage.TryDequeue(out var added))                 now += added;             totalSpeed = now;         }, null, 0, TimerInterval);          private static readonly ConcurrentQueue<long> ReceivedStorage = new ConcurrentQueue<long>();          public static void Clear()         {             while (ReceivedStorage.TryDequeue(out _))             {             }              totalSpeed = 0;         }          public static void AddInfo(long received)         {             ReceivedStorage.Enqueue(received);         }     }

По сравнению с первым вариантом, такая реализация начинает реагировать на паузу — скорость снижается до 0 в ближайшую секунду после того, как перестают приходить данные снаружи.
Но, есть и минусы. Мы работаем с буфером в 80кб, а значит загрузка начатая в одной секунде, отобразится только в следующей. И при большом потоке параллельных загрузок такие погрешности в измерениях будут отображать что угодно — у меня разброс был до 30% от реальных цифр. Я бы может и не заметил, но превышение 100мбит выглядело слишком уж подозрительно.

Третий подход

Второй вариант уже достаточно близок к правде, плюс у него ошибка наблюдалась больше на старте закачки, а не на всём жизненном цикле.
Поэтому, простое решение — брать в качестве показателя не цифру за секунду, а среднюю за три последние секунды. Три здесь — магическая константа, подобранная на глаз. С одной стороны хотелось приятное отображение роста и спада скорости, с другой — чтобы скорость была поближе к правде.

Реализация чуть усложняется, но в целом ничего такого:

    public class NetworkSpeed     {         public static double TotalSpeed { get { return totalSpeed; } }          private static double totalSpeed = 0;          private const uint Seconds = 3;          private const uint TimerInterval = 1000;          private static Timer speedTimer = new Timer(state =>         {             var now = 0L;             while (ReceivedStorage.TryDequeue(out var added))                 now += added;             LastSpeeds.Enqueue(now);             totalSpeed = LastSpeeds.Average();             OnUpdated(totalSpeed);         }, null, 0, TimerInterval);          private static readonly LimitedConcurrentQueue<double> LastSpeeds = new LimitedConcurrentQueue<double>(Seconds);          private static readonly ConcurrentQueue<long> ReceivedStorage = new ConcurrentQueue<long>();          public static void Clear()         {             while (ReceivedStorage.TryDequeue(out _))             {             }             while (LastSpeeds.TryDequeue(out _))             {             }              totalSpeed = 0;         }          public static void AddInfo(long received)         {             ReceivedStorage.Enqueue(received);         }          public static event Action<double> Updated;          private class LimitedConcurrentQueue<T> : ConcurrentQueue<T>         {             public uint Limit { get; }              public new void Enqueue(T item)             {                 while (Count >= Limit)                     TryDequeue(out _);                 base.Enqueue(item);             }              public LimitedConcurrentQueue(uint limit)             {                 Limit = limit;             }         }          private static void OnUpdated(double obj)         {             Updated?.Invoke(obj);         }     }

Пара моментов:

• на момент реализации не нашел готовой очереди с ограничением на количество элементов и взял её в интернете, в коде выше это LimitedConcurrentQueue.
• вместо реализации INotifyPropertyChanged почему то Action, использование фактически одинаковое, причин не помню. Логика простая — показатель меняется, надо пользователей об этом уведомить. Реализация может быть любой, хоть IObservable, кому как удобнее.

И немного читабельности

API отдает скорость в байтах, для читаемости пригодится простой (взятый в интернете)

    public static string HumanizeByteSize(this long byteCount)     {       string[] suf = { "B", "KB", "MB", "GB", "TB", "PB", "EB" }; //Longs run out around EB       if (byteCount == 0)         return "0" + suf[0];       long bytes = Math.Abs(byteCount);       int place = Convert.ToInt32(Math.Floor(Math.Log(bytes, 1024)));       double num = Math.Round(bytes / Math.Pow(1024, place), 1);       return Math.Sign(byteCount) * num + suf[place];     }      public static string HumanizeByteSize(this double byteCount)     {       if (double.IsNaN(byteCount) || double.IsInfinity(byteCount) || byteCount == 0)         return string.Empty;        return HumanizeByteSize((long)byteCount);     }

Напомню, что скорость в байтах, т.е. на 100мбитный канал должно выдать не более 12.5МБ.

Как это в итоге выглядит:

Заключение

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

Хочется сказать спасибо Stack Overflow на русском и конкретно VladD-exrabbit — в хорошем вопросе хоть и есть половина ответа, но любые подсказки и любая помощь всегда двигают тебя вперёд.

Хочу напомнить, что это pet-project — поэтому класс статический и один на всех, поэтому точность не особо. Я вижу много мелочей, которые можно было бы сделать лучше, но… всегда есть чем заняться ещё, так что пока скорость я считаю вот так и считаю что это не самый плохой вариант.