IEnumerable<Items> remainingItems = Items
var results = new List<List<Items>>();
var counter = 0;
while (remainingItems.Any())
{
    var result = new List<Item>();
    result.AddRange(remainingItems.TakeWhile(x => somePredicate(x, counter));
    results.Add(result);
    remainingItems = remainingItems.Skip(result.Count);
    counter++;
}

while (remainingItems.Any())
{
    var result = new List<Item>();
    result.AddRange(remainingItems.TakeWhile(x => somePredicate(x, counter));
    results.Add(result);
    remainingItems = remainingItems.Skip(result.Count).Memoize();
    counter++;
}

remainingItems = remainingItems.Skip(result.Count).Memoize();

remainingItems.Any()

result.AddRange(remainingItems.TakeWhile(x => somePredicate(x, counter));

using MoreLinq.Experimental;

for(int i = 0 ; i < result.Count ; i++){
       //do some business logic and now i got X result
      i = i + X
    }

public static IEnumerable<IEnumerable<T>> Test<T>(IEnumerable<T> source)
{
    var items = new List<T>();

    foreach (T item in source)
    {
        items.Add(item);

        if (!SomePredicate(item))
        {
            yield return items;
            items = new List<T>();
        }
    }

    // if you want any remaining items to go into their own IEnumerable, even if there's no more fails
    if (items.Count > 0)
    {
        yield return items;
    }
}

public static IEnumerable<IEnumerable<T>> PartitionBy<T>(this IEnumerable<T> sequence, Func<T, int, bool> predicate)
{
    var block = new List<T>();
    int index = 0;

    foreach (var item in sequence)
    {
        if (predicate(item, index++))
        {
            block.Add(item);
        }
        else if (block.Count > 0)
        {
            yield return block.ToList(); // Return a copy so the caller can't change our local list.
            block.Clear();
        }
    }

    if (block.Count > 0)
        yield return block; // No need for a copy since we've finished using our local list.
}

static void Main()
{                         //  0  1  2  3  4  5  6  7  8  9
    var ints = new List<int> {0, 1, 0, 3, 4, 5, 0, 0, 8, 9};

    var result = ints.PartitionBy(((item, index) => item == index)); // Items where value == index.

    foreach (var seq in result)
        Console.WriteLine(string.Join(", ", seq));

    // Output is:
    // 0, 1
    // 3, 4, 5
    // 8, 9
}

class Indexer
{
    public int  Index;
    public bool Finished;
}

public static IEnumerable<IEnumerable<T>> PartitionBy<T>(this IEnumerable<T> sequence, Func<T, int, bool> predicate)
{
    var iter = sequence.GetEnumerator();
    var indexer = new Indexer();

    while (!indexer.Finished)
    {
        yield return nextBlock(iter, predicate, indexer);
    }
}

static IEnumerable<T> nextBlock<T>(IEnumerator<T> iter, Func<T, int, bool> predicate, Indexer indexer)
{
    int index = indexer.Index;
    bool any = false;

    while (true)
    {
        if (!iter.MoveNext())
        {
            indexer.Finished = true;
            yield break;
        }

        if (predicate(iter.Current, index++))
        {
            any = true;
            yield return iter.Current;
        }
        else
        {
            indexer.Index = index;

            if (any)
                yield break;
        }
    }
}

IEnumerable<int> remainingItems = new[] { 1, 1, 2, 2, 2, 3, 4, 6, 7, 10, 12 };
        var results = new List<List<int>>();
        var counter = 0;
        var iterator = remainingItems.GetEnumerator();
        for (var done = !iterator.MoveNext();!done;)
        {
            var result = new List<int>();
            while (!done && SomePredicate( iterator.Current, counter ))
            {
                result.Add( iterator.Current );
                if (!iterator.MoveNext())
                    done = true;
            }
            results.Add( result );
            counter++;
        }