Looking for byte[] in larger byte[] similar to String's IndexOf()?

You can do it with LINQ, like this:

var res = Enumerable.Range(0, large.Length-1) .Cast<int?>() .FirstOrDefault(n => large.Skip(n.Value).Take(small.Length).SequenceEqual(small)); if (res != null) { Console.Println("Found at {0}", res.Value); } else { Console.Println("Not found"); } 

The approach is self-explanatory except for the Cast<int?> part: you need it to decide between finding the result at the initial location of the large array, when zero is returned, and not finding the result at all, when the return is null.

Here is a demo on ideone.

The complexity of the above is O(M*N), where M and N are lengths of the large and small arrays. If the large array is very long, and contains a significant number of "almost right" sub-sequences that match long prefixes of small, you may be better off implementing an advanced algorithm for searching sequences, such as the Knuth–Morris–Pratt (KMP) algorithm. The KMP algorithm speeds up the search by making an observation that when a mismatch occurs, the small sequence contains enough information on how far ahead you can move in the large sequence based on where in the small sequence is the first mismatch. A look-up table is prepared for the small sequence, and then that table is used throughout the search to decide how to advance the search point. The complexity of KMP is O(N+M). See the Wikipedia article linked above for pseudocode of the KMP algorithm.