// заведем по два read-only потока и по потоку для передачи информации
// об обновлениях фильтров фиксированных и динамических
private changesStream: Subject<number> = new Subject<number>();
private changesSubscription?: Subscription;
private filtersChanged: Subject<void> = new Subject<void>();
private filtersQueue?: Subscription;
// при загрузке страницы добавляем обработчики событий из потоков
// в данном случае мы просто добавляем задержку 0.7 секунды между совершением
// события и стартом реакции на него, в данном случае загрузкой и заполнением
// таблицы
this.changesSubscription = this.changesStream.pipe(
      debounceTime(700)
).subscribe(() => this.reloadData());
// на событие изменения динамических фильтров мы реагируем с задержкой в 3
// секунды, за которые пользователь предположительно должен успеть ввести все
// требуемые условия.
// По истечению 3-х секунд мы получаем список запросов на получение количества
// записей для каждой опции и подменяем этим списком текущую очередь, если она
// есть, с помощью метода switchMap
this.filtersQueue = this.filtersChanged.pipe(
      debounceTime(3000),
      switchMap(ev => from(this.getCountRequestObservables()))
).subscribe();

//
// Метод получения выражения для условия полного равенства значения поля
// сущности, обращение к которому хранится в memberExpression, и значений из
// переданного списка.
// Если значение для сравнения передано одно, то возвращаем выражение с вызовом
// метода Equal. Если больше одного, то вызовы метода Equal для каждого из
// значений объединяем с помощью OrElse.
// По ходу составления приводим тип значений из списка к типу поля.
//
internal static Expression GetEqualComparingExpression<T>(MemberExpression memberExpression, IList<T> values)
{
  int valuesCount = values.Count();
  if (valuesCount == 1)
  {
    return Expression.Equal(memberExpression, Expression.Convert(Expression.Constant(values.First()), memberExpression.Type));
  }
  if (valuesCount > 1)
  {
    if (memberExpression.Type != typeof(T))
    {
      // В случае, если значения для сравнения имеют тип, отличный от типа поля, значения которого будем сравнивать, то
      // попробуем конвертировать значения в тип, соответствующий типу поля
      MethodInfo convertingMethod = typeof(QueryExpressionFactory).GetMethod(nameof(ConvertList)).MakeGenericMethod(memberExpression.Type, typeof(T));
      object list = convertingMethod.Invoke(typeof(QueryExpressionFactory), new[] { values });
      return Expression.Call(Expression.Constant(list), list.GetType().GetMethod("Contains", new[] { memberExpression.Type }), memberExpression);
    }
    return Expression.Call(Expression.Constant(values), typeof(List<T>).GetMethod("Contains", new[] { typeof(T) }), memberExpression);
  }
  // Если список вариантов пуст, то возвращаем заранее неисполнимое условие (0 == 1), чтобы не было выбрано ни единой записи
  return Expression.Equal(Expression.Constant(0), Expression.Constant(1));
}
//
// Для того, чтобы компилятор завершил работу успешно, пришлось приведение
// типа значений из списка к требуемому типу вынести в отдельный обобщенный
// метод
//
private static List<TResult> ConvertList<TResult, TOrigin>(IList<TOrigin> values)
{
  var convertedList = new List<TResult>();
  foreach (TOrigin value in values)
  {
    convertedList.Add(ChangeType<TResult>(value));
  }
  return convertedList;
}
//
// Метод для конвертации каждого отдельного элемента из списка, причем мы
// добавили проверку на то, что конвертируем только типы из Nullable в конечные
//
private static TResult ChangeType<TResult>(object value)
{
  Type resultType = typeof(TResult);
  if (resultType.IsGenericType && resultType.GetGenericTypeDefinition() == typeof(Nullable<>))
  {
    if (value == null)
    {
      return default;
    }
    resultType = Nullable.GetUnderlyingType(resultType);
  }
  return (TResult)Convert.ChangeType(value, resultType);
}
//
// Метод получения выражения сравнения части значения поля с любой из переданных
// строк.
// Если значение для сравнения передано одно, то возвращаем выражение с вызовом
// метода Contains. Если больше одного, то вызовы метода Contains для каждого из
// значений объединяем с помощью OrElse.
// В данном случае приведение типов уже не требуется.
//
internal static Expression GetStringContainsComparingExpression(MemberExpression memberExpression, IEnumerable<string> values)
{
  int valuesCount = values.Count();
  Type stringType = typeof(string);
  if (valuesCount == 1)
  {
    return Expression.Call(memberExpression, stringType.GetMethod("Contains", new[] { stringType }), Expression.Constant(values.First()));
  }
  if (valuesCount > 1)
  {
    var comparingExpressions = new List<MethodCallExpression>();
    foreach (string value in values)
    {
      comparingExpressions.Add(Expression.Call(memberExpression, stringType.GetMethod("Contains", new[] { stringType }), Expression.Constant(value)));
    }
    BinaryExpression binaryExpression = Expression.OrElse(comparingExpressions[0], comparingExpressions[1]);
    if (valuesCount > 2)
    {
      for (int i = 2; i < comparingExpressions.Count(); i++)
      {
        binaryExpression = Expression.OrElse(binaryExpression, comparingExpressions[i]);
      }
    }
    return binaryExpression;
  }
  // Если список вариантов пуст, то возвращаем заранее неисполнимое условие (0 == 1), чтобы не было выбрано ни единой записи
  return Expression.Equal(Expression.Constant(0), Expression.Constant(1));
}

//
// Метод объединения коллекции выражений сравнения в одно выражение.
// Если коллекция содержит только одно выражение, возвращаем его. Если
// несколько, то объединяем их все с помощью метода AndAlso.
//
internal static Expression<Func<T, bool>> CreateConditionalExpression<T>(ParameterExpression baseExpression, IList<Expression> expressions) where T : Entity
{
  Expression<Func<T, bool>> conditionsPredicate = null;
  int filtersCount = expressions.Count();
  if (filtersCount > 0)
  {
    if (filtersCount == 1)
    {
      conditionsPredicate = Expression.Lambda<Func<T, bool>>(expressions.First(), baseExpression);
    }
    else
    {
      BinaryExpression filtersPredicate = Expression.AndAlso(expressions[0], expressions[1]);
      if (filtersCount > 2)
      {
        for (int i = 2; i < expressions.Count(); i++)
        {
          filtersPredicate = Expression.AndAlso(filtersPredicate, expressions[i]);
        }
      }
      conditionsPredicate = Expression.Lambda<Func<T, bool>>(filtersPredicate, baseExpression);
    }
  }
  return conditionsPredicate;
}