Is it possible to increment the identifier in a foreach loop without evaluation of its expression?

Question

I have a collection of objects that I would like to iterate through to ultimately recognize some type of pattern. Currently I have a bunch of if statements that checks a flag for the expression. For example I have something along the lines of if (!foundFirstObjectOfTypeA). Once I found the first object of type A I would set the flag to true and we would no longer execute the block and move on to the next block. I have several types of patterns to recognize and because of this it has created a large block of if statements that are hard to understand and ugly.

Is there a way to peek/look past the identifier without the evaluation of the expression in the foreach loop? If I could do something along the lines of if (identifer == ObjectA && identifer.next == ObjectB) it would make my code much more readable and understandable and I could deal without having to set flags.

If there is no direct method/way does someone have some clever workarounds to simulate the effects I desire?

Answer 1

Use a for loop instead to increment i, then just look at object[i] and object[i+1]. What type of collection are you using? A list? An array? All a foreach loop does is hide the counter from you. There's absolutely no reason to use a foreach loop instead of a for loop, if I understand your situation.

This should work for any list and any sequence of objects:

Function:

public static bool ContainsSequence
    (System.Collections.Generic.IList<object> list, params object[] seq)
{
    for (int i = 0; i < list.Count() - seq.Count() + 1; i++)
    {
        int j;
        for (j = 0; j < seq.Count(); j++)
        {
            if (list[i + j] != seq[j])
                break;
        }
        if (j == seq.Count())
            return true;
    }
    return false;
}

Usage:

private static void Main(string[] args)
{
    var A = new object();
    var B = new object();
    var C = new object();
    var D = new object();

    var list = new[] {A, B, C, D};
    Console.WriteLine(ContainsSequence(list, B, C, D));
    Console.WriteLine(ContainsSequence(list, A, D, C, B, A, C));
    Console.WriteLine(ContainsSequence(list, A, B));
}

Output:

True
False
True

The function can be made simpler if you know how many objects you're looking for (if you're only looking for two, it's almost Hamid Nazari's answer - you just need to add AndrewS's bound checking, below.)

If you want the index of the start of the sequence, you can change the return type of my function to an int and return i instead of true (and return -1 instead of false.)

Answer 2

I don't think there is direct support for it, but you can always emulate.

For example (part of a solution):

  static IEnumerable<Peekable<T>> ToPeekable(this IEnumerable<T> stream)
  {
     T prev = <get first item, and move...>
     foreach(T item in stream)
     {
       yield return new Peekable<T>(prev, item);
       prev = item;
    }
    yield return new Peekable<T>(item, default(T));
  }

Update: Missing parts

class Peekable<T>
{
    public Peekable(T current, T next)
    {
        Current = current;
        Next = next;
    }

    public T Current { get; private set; }
    public T Next { get; private set; }
}

static class PeekableAdaptor
{
    public static IEnumerable<Peekable<T>> ToPeekable<T>(this IEnumerable<T> stream)
    {
        var source = stream.GetEnumerator();

        if (!source.MoveNext()) 
            yield break;

        T prev = source.Current;

        while (source.MoveNext())
        {
            yield return new Peekable<T>(prev, source.Current);
            prev = source.Current;
        }

        yield return new Peekable<T>(prev, default(T));
    }
}

class Program
{
    static void Main(string[] args)
    {
        foreach (var pair in Enumerable.Range(1, 10).ToPeekable())
        {
            Console.WriteLine(pair.Current, pair.Next);
        }
    }
}

Answer 3

If you use a for loop, you can do something like this.

for (int i = 0; i < list.Count - 1; i++)
    if (list[i] == ObjectA && list[i + 1] == ObjectB)
        ; // Your code

Answer 4

IEnumerable is a very light forward-only iterator implementation. If you have a look at IEnumerator interface, there are only three members:

As a solution, you could iterate through the IEnumerable manually or use loops.

bool MoveNext()
void Reset()
object Current

So the only operations are to go forward, reset and to retrieve the current item. There is no built-in ability to peek what coming next.

IEnumerable version

bool someFlag = false;
IEnumerable<object> collection = new object[]{"string", true, 4, DateTime.Now};
using (var enumerator = collection.GetEnumerator()) {
  while (true ) {
   bool end = enumerator.MoveNext();
   if (!end) {
      if (enumerator.Current.GetType() == typeof(string)) {
        end = enumerator.MoveNext();
        if (!end && enumerator.Current.GetType() == typeof(bool))
          someFlag = true;
      }
   } 
   if (end) break;
  }
}

Loop version

bool someFlag = false;
List<object> collection = new object[]{"string", true, 4, DateTime.Now};
int i = 0;
while (true ) {
   bool end = i < collection.Count;
   if (!end) {
      if (collection[i] == typeof(string)) {
        i++;
        end = i < collection.Count;
        if (!end && collection[i] == typeof(bool))
          someFlag = true;
      }
   } 
   if (end) break;
  }
}

Answer 5

Using my answer to this question I came up with this variation as a possible solution. This will work for any type of collection; even those that cannot be indexed.

foreach (var item in ForEachHelper.Wrap(collection))
{
    Console.WriteLine("Position=" + item.Index.ToString());
    Console.WriteLine("Current=" + item.Current.ToString());
    if (item.HasNext)
    {
        Console.WriteLine("Next=" + item.Next.ToString());
    }
}

And here is the relevant code.

public static class ForEachHelper
{
    public sealed class Item<T>
    {
        public int Index { get; set; }
        public T Current { get; set; }
        public T Next { get; set; }
        public bool HasNext { get; set; }
    }

    public static IEnumerable<Item<T>> Wrap<T>(IEnumerable<T> enumerable)
    {
        IEnumerator<T> enumerator = enumerable.GetEnumerator();
        try
        {
            var item = new Item<T>();
            item.Index = 0;
            item.Current = default(T);
            item.Next = default(T);
            item.HasNext = false;
            if (enumerator.MoveNext())
            {
                item.Current = enumerator.Current;
                if (enumerator.MoveNext())
                {
                    item.Next = enumerator.Current;
                    item.HasNext = true;
                }
                while (item.HasNext)
                {
                    var next = new Item<T>();
                    next.Index = item.Index + 1;
                    next.Current = item.Next;
                    next.Next = default(T);
                    if (enumerator.MoveNext())
                    {
                        next.Next = enumerator.Current;
                        next.HasNext = true;
                    }
                    var current = item;
                    item = next;
                    yield return current;
                }
                yield return item;
            }
        }
        finally
        {
            enumerator.Dispose();
        }
    }
}