Как не дать пользователю заснуть во время загрузки большого набора данных

Одно из двух, — прошелестел он, — или пациент жив, или он умер. Если он жив — он останется жив или он не останется жив. Если он мёртв — его можно оживить или нельзя оживить.

А.Н. Толстой. "Золотой ключик, или Приключения Буратино"

Введение

Недавно в организации, где я тружусь, появилась идея переписать корпоративную систему, которая работает более 20 лет и за этот срок несколько устарела. Если кратко - информационная система в области морских грузовых перевозок и обслуживания судов в порту. В данный момент я занимаюсь НИОКР и хочу поделиться с вами некоторыми проблемами, с которыми может столкнуться разработчик подобной системы и как я планирую их решать. На текущий момент планирую сервер приложений ASP.NET Core под .NET 6. База данных останется старая, так как это даст возможность постепенно переходить на новую систему по мере добавления функционала. Основное клиентское ПО предполагается на WPF под .NET 6. Кроме того, возможны небольшие узкопрофильные клиенты на веб-страницах и мобильных устройствах.

Проблема

Пользователю лень фильтровать запрашиваемые данные, а их довольно много. Заставлять пользователя что-то фильтровать - негуманно и попахивает произволом. В текущей системе такой пользователь сидит грустит, ругает разработчиков, давит на техподдержку. В текущей системе клиент идёт прямо в базу данных через BDE, ничего с этим сделать уже нельзя. В новой системе клиент про базу данных ничего не знает, сервер по его запросу шлет JSON через HTTP. Если делать "в лоб", то сильно мало что поменяется: сервер по запросу клиента будет собирать для отправки коллекцию объектов, загружая их из базы или ещё как-то. Потом всю эту махину он пошлёт в ответном HTTP-пакете, предварительно серилизовав в JSON, там это всё будет в один присест десериализовано в клиентские объекты, которые, наконец-то предстанут пред взором потерявшего надежду пользователя.

Идея решения

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

Предположим, у нас есть следующий класс:

public enum PartialLoaderState { New, Partial, Full ... }

public class PartialLoader<T> where T: class
{
		// Возвращает текущее состояние: новый или данные получены (полностью или 
    // частично)
    PartialLoaderState State { get; }
    // Выполняет загрузку очередной партии данных
    Task LoadAsync()
    {
    	...
    }
  	// Устанавливает источник данных
    public PartialLoader<T> SetDataProvider(IAsyncEnumerable<T> dataProvider)
    {
    	...
    }
  	// Задаёт таймаут, после истечения которого происходит возврат из 
  	// метода LoadAsync()
  	public PartialLoader<T> SetTimeout(TimeSpan timeout)
    {
      ...
    }
  	// Задаёт размер партии данных, после достижения которого происходит 
  	// возврат метода LoadAsync()
  	public PartialLoader<T> SetPaging(int paging)
    {
      ...
    }
  	// Добавляет "утилизатор" в цепочку обработчиков каждого элемента
  	public PartialLoader<T> AddUtilizer(Action<T> utilizer)
    {
      ...
    }
    ...
}

Данный класс может быть также унаследован с предопределёнными "утилизаторами". В этой статье мы будем использовать класс ChunksPartialLoader, который помещает очередную порцию в List<T>, заменяя предыдущую порцию.

public class ChunkPartialLoader<T> : PartialLoader<T> where T : class
{
    private readonly List<T> _chunk = new();
  
  	public List<T> Chunk
    {
        get
        {
          ...
            return _chunk;
        }
    }
  	public override async Task LoadAsync()
    {
        AddUtilizer(Utilizer);
        _chunk.Clear();
        await base.LoadAsync();
    }
  	private void Utilizer(T item)
    {
        _chunk.Add(item);
    }
}

Посмотрим, как этим можно воспользоваться.

Лабораторная установка

Чтобы испытать, как всё работает, создадим в VisualStudio Studio Community 2022 три проекта. Здесь опишу по возможности кратко, так как все исходники доступны: https://sourceforge.net/p/partialloader/code/ci/v1.1.0/tree/.

• BigCatsDataContract - библиотека классов, общих для сервера и клиента. Здесь находится класс, описывающий элемент данных, в нашем случае - кошку. Также присутствует класс с некоторыми константами.

public class Cat
{
    public string Name { get; set; }
}

public class Constants
{
  	public const string PartialLoaderStateHeaderName = 
      "X-CatsPartialLoaderState";
  	public const string PartialLoaderSessionKey = 
      "X-CatsPartialLoaderSessionKey";
  	public const string Partial = "Partial";
  	public const string Full = "Full";
}

• BigCatsDataServer - проект ASP.NET Core. В Program.cs Мы обрабатываем два маршрута с параметрами:

// Запрашиваем count кошек одной партией с заданной задержкой delay, 
// требующейся для загрузки каждой кошки
app.MapGet("/cats/{count=1001}/{delay=0}",
    async (HttpContext context, int count, double delay) =>
    await Task.Run(() => CatsGenerator.GetCats(context, count, delay))
);
// Запрашиваем count кошек с заданной задержкой delay, 
// требующейся для загрузки каждой кошки, партиями, размеры которых 
// ограничены таймаутом timeout или фиксированной величиной paging
app.MapGet("/catsChunks/{count=1001}/{timeout=100}/{paging=1000}/{delay=0}",
    async (HttpContext context, int count, int timeout, int paging, 
           double delay) =>
    await Task.Run(() => CatsGenerator.GetCatsChunks(context, count, timeout, 
                                                     paging, delay))
);

В классе CatsGenerator расположены метод, генерирующий данные и методы, обрабатывающие HTTP-запросы:

public class CatsGenerator
{
    private const string CatNamePrefix = "Кошка №";

	  public static async IAsyncEnumerable<Cat> GenerateManyCats(int count,
                                                              double delay)
    {
    		...
              
        yield return await Task.Run(() => 
        {
            if (delay > 0)
            {
                // Если задали ненулевой delay, имитируем бурную 
                // деятельность продолжительностью примерно delay миллисекунд.
            }
            return new Cat { Name = $"{CatNamePrefix}{i + 1}" }; 
        });
    }

    /// <summary>
    ///     Метод, возвращающий всех кошек сразу.
    /// </summary>
    public static async Task GetCats(HttpContext httpContext, int count, 
                                      double delay)
    {
        List<Cat> cats = new();
        await foreach(Cat cat in GenerateManyCats(count, delay))
        {
            cats.Add(cat);
        }
        await httpContext.Response.WriteAsJsonAsync<List<Cat>>(cats);
    }

    /// <summary>
    ///     Метод, возвращающий кошек партиями. 
    /// </summary>
    public static async Task GetCatsChunks(HttpContext context, int count, 
                                   int timeout, int paging, double delay)
    {
        IPartialLoader<Cat> partialLoader;
        string key = null!;

        // Получаем хранилище через механизм внедрения зависимостей. 
      	// Хранилище зарегистрировано, как Singleton, поэтому живёт вечно.
        CatsLoaderStorage loaderStorage = 
              context.RequestServices.GetRequiredService<CatsLoaderStorage>();

        if (!context.Request.Headers.ContainsKey(
          Constants.PartialLoaderSessionKey))
        {
            // Если это первый запрос, то создаём IPartialLoader (В нашем 
          	// случае получаем через механизм внедрения зависимостей, где он 
          	// зарегистрирован как Transient) и стартуем генерацию.
            partialLoader = context.RequestServices.
              GetRequiredService<IPartialLoader<Cat>>();
            partialLoader
                    .SetTimeout(TimeSpan.FromMilliseconds(timeout))
                    .SetPaging(paging)
                    .SetDataProvider(GenerateManyCats(count, delay))
                    ;
        } 
        else
        {
            // Если это последующий запрос, то получаем ключ из заголовка 
          	// запроса, берём PartialLoader из хранилища и продолжаем 
          	// генерацию.
            key = context.Request.Headers[Constants.PartialLoaderSessionKey];
            partialLoader = loaderStorage.Data[key];
        }
       	await partialLoader.LoadAsync();

        // Добавляем заголовок ответа, сигнализирующий, последняя это партия 
      	// или нет.
        context.Response.Headers.Add(Constants.PartialLoaderStateHeaderName,
                                     partialLoader.State.ToString());

            if(partialLoader.State == PartialLoaderState.Partial)
            {
                // Если партия не последняя, 
                if(key is null)
                {
                    // Если партия первая, придумываем ключ и помещаем 
                  	// IPartialLoader в хранилище.
                    key = Guid.NewGuid().ToString();
                    loaderStorage.Data[key] = partialLoader;
                }
                // Добавляем заголовок ответа с ключом.
                context.Response.Headers.Add(
                  Constants.PartialLoaderSessionKey, key);
            }
            else
            {
                // Если партия последняя, удаляем IPartialLoader из хранилища.
                if (key is not null)
                {
                    loaderStorage.Data.Remove(key);
                }
            }


            await context.Response.WriteAsJsonAsync<List<Cat>>(
              partialLoader.Chunk);
        }
    }

• BigCatsDataClient - проект WPF. Разметку рассматривать не будем, а в code-behind для простоты размещены методы, запрашивающие список кошек полностью и частями. Код для краткости привожу не полностью, он доступен в исходниках.

private const string Server = "https://localhost:7209";

/// <summary xml:lang="ru">
///     Метод загрузки целиком.
/// </summary>
private async Task GetAllCats()
{
  	...
    try
    {
      	...
        using HttpClient _client = new HttpClient();
        ...
        _client.BaseAddress = new Uri(Server);

        // Передаём запрос серверу в стиле REST
        HttpRequestMessage request = new HttpRequestMessage(
          HttpMethod.Get,
          $"{Constants.AllUri}/{Count}/{Delay.ToString().Replace(',', '.')}");
        HttpResponseMessage response = await _client.SendAsync(request);

        if(response.StatusCode == System.Net.HttpStatusCode.OK)
        {
            await Dispatcher.BeginInvoke(async () =>
            {
                List<Cat>? list = await JsonSerializer.
                  DeserializeAsync<List<Cat>>(
                  		response.Content.ReadAsStream(),
                        new JsonSerializerOptions { 
                          PropertyNameCaseInsensitive = true 
                          });
                    // Добавляем кошек в таблицу с кошками
                foreach (Cat cat in list)
                {
                    Cats.Add(cat);
                }
								...
            });
        }
      	...

    }
    catch (Exception ex)
    {
        // Что-то пошло вообще не так
      	...
    }
}

/// <summary xml:lang="ru">
///     Метод загрузки частями.
/// </summary>
private async Task GetChunksCats()
{
  	...
    try
    {
      	... 
           
        using HttpClient _client = new HttpClient();
    		...
        _client.BaseAddress = new Uri(Server);

        // Передаём запрос серверу в стиле REST
        HttpRequestMessage request = new HttpRequestMessage(
          HttpMethod.Get, 
          $"{Constants.ChunkslUri}/{Count}/{Timeout}/{Paging}/{Delay.ToString().Replace(',', '.')}");
        HttpResponseMessage response = await _client.SendAsync(request);
    		...
        while(response.StatusCode == System.Net.HttpStatusCode.OK
              && IsDataLOading)
        {
            await Dispatcher.BeginInvoke(async () =>
            {
                List<Cat>? list = await JsonSerializer.
                  DeserializeAsync<List<Cat>>(
                  response.Content.ReadAsStream(),
                        new JsonSerializerOptions { 
                          PropertyNameCaseInsensitive = true });

                // Добавляем кошек в таблицу с кошками
                foreach (Cat cat in list)
                {
                    Cats.Add(cat);
                }

								...
                      
                if (response.Headers.GetValues(
                  Constants.PartialLoaderStateHeaderName).First() == 
                    Constants.Partial)
                {
                    // Если данные пришли не полностью, повторяем запрос. 
                  	// Можно без параметров, так как сервер подставит 
                  	// значения по умолчанию,
                    // но они всё равно не будут использоваться, 
                  	// так как мы передаём заголовок с идентификатором запроса,
                  	// который сервер
                    // вернул нам с неполными данными.
                    request = new HttpRequestMessage(
                      HttpMethod.Get, $"{Constants.ChunkslUri}");
                    request.Headers.Add(
                      Constants.PartialLoaderSessionKey, 
                      response.Headers.GetValues(
                        Constants.PartialLoaderSessionKey).First());
                    response = await _client.SendAsync(request);
                }
               	...
            });
        }
       	...
    }
    catch (Exception ex)
    {
       // Что-то пошло вообще не так
     	...
    }
}

Запустим сервер и клиент.

Будем запрашивать 100000 кошек с задержкой 0.1 миллисекунд на каждую.

Сначала нажмём "Получить сразу всё".

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

Теперь попробуем получить частями. Таймаут поставим 200, меньше нет смысла, так как в PartialLoader мы используем ManualResetEventSlim.Wait(...) и меньшую задержку мы не сможем выдержать.

Видим, что уже через десятые доли секунды пользователь увидел первые данные.

Попробуем вместо таймаута задать размер партии.

Как видим, всё прошло по плану.

Ну и оба параметра:

После нескольких попыток удалось подобрать размер партии такой, что timeout и paging сработали примерно поровну - 51% в пользу paging.

О реализации PartialLoader

Ну и несколько слов о реализации PartialLoader, использованной для данной демонстрации. При первом вызове LoadAsync(...) запускается задача, которая читает асинхронный Enumerable и записывает их в очередь. Как первый, так и последующие вызовы LoadAsync() читают данные из этой очереди в течение времени, соответствующего заданным параметрам. Для совместного доступа потоков к очереди используется ManualResetEventSlim. Вначале он сброшен. Когда задача, пишущая в очередь, добавляет объект, она устанавливает ManualResetEventSlim, и происходит чтение из очереди. Когда очередь пустеет, ManualResetEventSlim сбрасывается. Подробнее реализацию можно посмотреть в исходниках.

public async Task StartAsync(IAsyncEnumerable<T> data, PartialLoaderOptions options)
{
		...
  
	if (State is PartialLoaderState.New)
  {
    	State = PartialLoaderState.Started;
  		_manualReset.Reset();
        
			_loadTask = Task.Run(async () =>
			{
					await foreach (T item in data)
		  		{
  						if (_cancellationTokenSource.Token.IsCancellationRequested)
    					{
    						...
        				break;
    					}
    					_queue.Enqueue(item);
    					_manualReset.Set();
					}
			});

		...
  }
  else
  {
    State = PartialLoaderState.Continued;
  }
  await ExecuteAsync();
  // вычищаем "утизизаторы" после каждого вызова, чтобы избежать
  // обращений к объектам, которые могут не сохранять функциональность
  // между вызовами, например, использовать HttpContext
  _utilizers.Clear();

}
  
private async Task ExecuteAsync()
{
    _start = DateTimeOffset.Now;
    _count = 0;

            
    while (!_loadTask.IsCompleted)
    {
        TimeSpan limeLeft = _timeout.Ticks <= 0 ?
                TimeSpan.MaxValue : _timeout - (DateTimeOffset.Now - _start);
        if (limeLeft == TimeSpan.MaxValue || limeLeft.TotalMilliseconds > 0)
        {
            try
            {
                if (limeLeft == TimeSpan.MaxValue)
                {
                    _manualReset.Wait(_cancellationTokenSource!.Token);
                }
                else
                {
                    _manualReset.Wait(limeLeft, _cancellationTokenSource!.Token);
                }
            }
            catch (OperationCanceledException) 
            {
                await _loadTask;
            }
            if (_cancellationTokenSource!.Token.IsCancellationRequested)
            {
              	await _loadTask;
                State = PartialLoaderState.Canceled;
                return;
            }
            if (UtilizeAndPossiblySetPartialStateAndReturn())
            {
            		return;
            }
        } 
        else
        {
            if (_cancellationTokenSource!.Token.IsCancellationRequested)
            {
                await _loadTask;
              	State = PartialLoaderState.Canceled;
                return;
            }
            State = PartialLoaderState.Partial;
          	return;
        }
        if (!_loadTask.IsCompleted)
        {
            _manualReset.Reset();
        }
    }
    if (UtilizeAndPossiblySetPartialStateAndReturn())
    {
    		return;
    }
    if (_cancellationTokenSource!.Token.IsCancellationRequested)
    {
      	State = PartialLoaderState.Canceled;
        return;
    }
    if (_loadTask.IsFaulted)
    {
        throw _loadTask.Exception!;
    }
    State = PartialLoaderState.Full;
}

private bool UtilizeAndPossiblySetPartialStateAndReturn()
{
		while (_queue.TryDequeue(out T? item))
    {
    		if (item is not null)
        {
        		foreach (Action<T> utilizer in _utilizers)
            {
              	utilizer.Invoke(item);
            }

            _count++;

            if (_paging > 0 && _count >= _paging || _timeout.Ticks > 0 && (_timeout - (DateTimeOffset.Now - _start)).Ticks <= 0)
            {
            		State = PartialLoaderState.Partial;
              	return true;
            }
        }
    }
    return false;
}

Вывод

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

NuGet: https://www.nuget.org/packages/Net.Leksi.PartialLoader/