Проекция запроса LINQ из нескольких операторов from

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

Когда вы делаете несколько предложений from в LINQ таким образом, это перекрестное соединение. Все, кроме первого, это призыв к SelectMany. Чтобы поддерживать произвольное количество входов, вам нужно пройти через них. Однако простой цикл foreach не совсем сработает, потому что первую последовательность нужно обрабатывать немного по-другому.

По-другому как? Две вещи. Во-первых, не на что звонить SelectMany. Если вы вызовете его для пустого списка, вы получите еще один пустой список. Таким образом, первый элемент в loops устанавливает базовый список. Реализация, которую я представил ниже, делает начинается с пустой последовательности, но она существует только в том случае, если в loops не найдены элементы. Он заменяется, когда найден первый элемент. И, во-вторых, по крайней мере в этой реализации вам нужно создать новый список из первого элемента, тогда как последующие соединения должны создать следующий элемент и создать новый список.

Еще одна вещь, о которой следует помнить, это то, что вам нужен тип результата, который может обрабатывать произвольное количество элементов. Я выбрал IEnumerable<List<Step>> для этого - я выбрал List<Step> в качестве типа элемента, потому что каждый индекс каждого списка будет соотноситься с этим индексом параметра loops, поэтому вы можете индексировать их оба напрямую. Например, элемент [5] каждого результата будет получен из loops[5].

Чтобы это произошло, я написал эквивалент цикла foreach, используя IEnumerator<T> напрямую. Для первого элемента в loops он создает список объектов Step для каждого результата, который вы хотите вернуть.

Для каждого последующего элемента в loops он выполняет перекрестное соединение с использованием SelectMany и объединяет их в новые списки, содержащие элементы с левой стороны и каждый элемент с правой стороны.

Перечислитель предоставляет свойство Current. Это освобождает итерации от привязки к заданному индексу. Вы заметите, что переменная current используется там, где раньше была loops[n].

Стоит отметить, что вызовы ToList необходимы для принудительной оценки, потому что переменная current не захватывается лямбда-выражениями так же, как переменная диапазона в цикле foreach.

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

public static IEnumerable<List<Step>> CreateSteps(IEnumerable<MinToMax> loops)
{
    IEnumerable<List<Step>> sequence = Enumerable.Empty<List<Step>>();

    using (IEnumerator<MinToMax> enumerator = loops.GetEnumerator())
    {
        if (enumerator.MoveNext())
        {
            MinToMax current = enumerator.Current;

            sequence = Enumerable
                .Repeat(current.Minimum, (current.Maximum - current.Minimum) / current.Increment + 1)
                .Select((tr, ti) => new List<Step>() { new Step() { Value = tr + current.Increment * ti, IsActive = true } })
                .ToList();

            while (enumerator.MoveNext())
            {
                current = enumerator.Current;

                sequence = sequence
                    .SelectMany(
                        ctx => Enumerable
                            .Repeat(current.Minimum, (current.Maximum - current.Minimum) / current.Increment + 1)
                            .Select((tr, ti) => new Step() { Value = tr + current.Increment * ti, IsActive = true }),
                        (list, value) => new List<Step>(list) { value }
                        )
                    .ToList();
            }
        }
    }

    return sequence;
}

Я также изменил параметр loops на IEnumerable<MinToMax>, потому что ничего о том, как метод использует его, не требует, чтобы он был списком. С другой стороны, я оставил элементы в возвращаемой последовательности как Lists, потому что это упростит сопоставление их элементов с исходным списком, как я упоминал ранее.

Можно выполнить еще один рефакторинг, например, извлечь выражение, переданное Enumerable.Repeat, в метод, чтобы его можно было использовать повторно.

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

static void Main(string[] args)
{
    List<MinToMax> loops = GetValuesIntoSteps();

    foreach (List<Step> loop in CreateSteps(loops))
    {
        foreach (Step step in loop)
        {
            Console.Write($"{step.Value} ");
        }
        Console.WriteLine();
    }
}

Надеюсь, это поможет.