C# 如何在特定偏移处找到 byte[] 模式

Question

I have this code to return a long of a byte pattern. How would I add it so it searches the byte at a specific offset?

static public long SearchBytePattern(byte[] pattern, byte[] bytes)
        {
            List<int> positions = new List<int>();
            int patternLength = pattern.Length;
            int totalLength = bytes.Length;
            byte firstMatchByte = pattern[0];
            for (int i = 0; i < totalLength; i++)
            {
                if (firstMatchByte == bytes[i] && totalLength - i >= patternLength)
                {
                    byte[] match = new byte[patternLength];
                    Array.Copy(bytes, i, match, 0, patternLength);
                    if (match.SequenceEqual<byte>(pattern))
                    {
                        positions.Add(i);
                        i += patternLength - 1;
                    }
                }
            }
            try
            {
                return positions[0];
            }
            catch (ArgumentOutOfRangeException)
            {
                MessageBox.Show("none found");
                return 0;
            }
            
        }

For example I want to do this: I want the SearchBytePattern to have a way to start to search from a specific offset, eg: start from offset 3 (which is offset 47).

          byte[] needle = new byte[]
            {
                111, 111, 111
            };
            byte[] haystack = new byte[]
            {
               111, 111, 111, 47,  111, 111, 111, 47,  111, 111, 111, 47
            };

SearchBytePattern(needle, haystack)

Answer 1

You will need a third parameter offset .

• Start searching at offset
• You can short-circuit the search as shown below, if the needle is too long compared to the haystack and offset .
• Instead of copying arrays, which will take up more memory and probably also time, just search inside the arrays themselves.
• This is still O(m * n) worst-case time complexity. You can make it O(m) by using a more sophisticated algorithm like Knuth-Morris-Pratt (but it is much more complicated and the overhead will not be worth it, for small inputs).

        public static int Search(byte[] needle, byte[] haystack, int offset){
            if (haystack.Length - offset < needle.Length) {
                return -1;   // can't possibly find b/c needle is too long
            }
            for (int i = offset; i < haystack.Length; ++i) {
                for (int j = 0; j < needle.Length; ++j) {
                    if ((i + j) >= haystack.Length || needle[j] != haystack[i + j]) {
                        break;       // found non-match for attempt
                    }
                    if (j == needle.Length - 1) {
                        return i;    // matched all
                    }
                }
            }
            return -1;
        }

The above returns 4 for your example input.