blocks|key|1476518|text|您可以将字节数组放入String并通过IndexOf运行match。或者，您至少可以重用existing+algorithms进行字符串匹配。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1476519|++++[STAThread]
++++static+void+Main(string[]+args)
++++{
++++++++byte[]+pattern+=+new+byte[]+{12,3,5,76,8,0,6,125};
++++++++byte[]+toBeSearched+=+new+byte[]+{23,36,43,76,125,56,34,234,12,3,5,76,8,0,6,125,234,56,211,122,22,4,7,89,76,64,12,3,5,76,8,0,6,125};
++++++++string+needle,+haystack;

++++++++unsafe+
++++++++{
++++++++++++fixed(byte+*+p+=+pattern)+{
++++++++++++++++needle+=+new+string((SByte+*)+p,+0,+pattern.Length);
++++++++++++}+//+fixed

++++++++++++fixed+(byte+*+p2+=+toBeSearched)+
++++++++++++{
++++++++++++++++haystack+=+new+string((SByte+*)+p2,+0,+toBeSearched.Length);
++++++++++++}+//+fixed

++++++++++++int+i+=+haystack.IndexOf(needle,+0);
++++++++++++System.Console.Out.WriteLine(i);
++++++++}
++++}|code-block|syntax|javascript|1476520|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/ezh7k8d5.aspx|1|http://en.wikipedia.org/wiki/String_searching_algorithm^0|A|6|0|18|J|1|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]|Q|$5|L|M|N|C|$O|R]]]]

You can put the byte array into <a href="http://msdn.microsoft.com/en-us/library/ezh7k8d5.aspx" rel="nofollow noreferrer">String</a> and run match by IndexOf. Or you can at least reuse <a href="http://en.wikipedia.org/wiki/String_searching_algorithm" rel="nofollow noreferrer">existing algorithms</a> on string matching.

<pre><code> [STAThread]
 static void Main(string[] args)
 {
 byte[] pattern = new byte[] {12,3,5,76,8,0,6,125};
 byte[] toBeSearched = new byte[] {23,36,43,76,125,56,34,234,12,3,5,76,8,0,6,125,234,56,211,122,22,4,7,89,76,64,12,3,5,76,8,0,6,125};
 string needle, haystack;

 unsafe 
 {
 fixed(byte * p = pattern) {
 needle = new string((SByte *) p, 0, pattern.Length);
 } // fixed

 fixed (byte * p2 = toBeSearched) 
 {
 haystack = new string((SByte *) p2, 0, toBeSearched.Length);
 } // fixed

 int i = haystack.IndexOf(needle, 0);
 System.Console.Out.WriteLine(i);
 }
 }
</code></pre>

blocks|key|1691691|text|toBeSearched.Except(pattern)将返回差异toBeSearched.Intersect(pattern)将生成一组交集通常，您应该查看Linq扩展中的扩展方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1691692|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

toBeSearched.Except(pattern) will return you differences
toBeSearched.Intersect(pattern) will produce set of intersections
Generally, you should look into extended methods within Linq extensions

blocks|key|1476586|text|我的解决方案是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1476587|class+Program
{
++++public+static+void+Main()
++++{
++++++++byte[]+pattern+=+new+byte[]+{12,3,5,76,8,0,6,125};

++++++++byte[]+toBeSearched+=+new+byte[]+{+23,+36,+43,+76,+125,+56,+34,+234,+12,+3,+5,+76,+8,+0,+6,+125,+234,+56,+211,+122,+22,+4,+7,+89,+76,+64,+12,+3,+5,+76,+8,+0,+6,+125};

++++++++List<int>+positions+=+SearchBytePattern(pattern,+toBeSearched);

++++++++foreach+(var+item+in+positions)
++++++++{
++++++++++++Console.WriteLine("Pattern+matched+at+pos+{0}",+item);
++++++++}

++++}

++++static+public+List<int>+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%2B%2B)
++++++++{
++++++++++++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+%2B=+patternLength+-+1;
++++++++++++++++}
++++++++++++}
++++++++}
++++++++return+positions;
++++}
}|code-block|syntax|javascript|1476588|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

My solution:

<pre><code>class Program
{
 public static void Main()
 {
 byte[] pattern = new byte[] {12,3,5,76,8,0,6,125};

 byte[] toBeSearched = new byte[] { 23, 36, 43, 76, 125, 56, 34, 234, 12, 3, 5, 76, 8, 0, 6, 125, 234, 56, 211, 122, 22, 4, 7, 89, 76, 64, 12, 3, 5, 76, 8, 0, 6, 125};

 List&lt;int&gt; positions = SearchBytePattern(pattern, toBeSearched);

 foreach (var item in positions)
 {
 Console.WriteLine("Pattern matched at pos {0}", item);
 }

 }

 static public List&lt;int&gt; SearchBytePattern(byte[] pattern, byte[] bytes)
 {
 List&lt;int&gt; positions = new List&lt;int&gt;();
 int patternLength = pattern.Length;
 int totalLength = bytes.Length;
 byte firstMatchByte = pattern[0];
 for (int i = 0; i &lt; totalLength; i++)
 {
 if (firstMatchByte == bytes[i] &amp;&amp; totalLength - i &gt;= patternLength)
 {
 byte[] match = new byte[patternLength];
 Array.Copy(bytes, i, match, 0, patternLength);
 if (match.SequenceEqual&lt;byte&gt;(pattern))
 {
 positions.Add(i);
 i += patternLength - 1;
 }
 }
 }
 return positions;
 }
}
</code></pre>

blocks|key|1476639|text|我会使用一种通过转换为字符串来进行匹配的解决方案...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1476640|您应该编写一个实现Knuth-Morris-Pratt+searching+algorithm的简单函数。这将是您可以用来查找正确索引的最快的简单算法。(您可以使用Boyer-Moore，但它需要更多的设置。|offset|length|1476641|在优化算法之后，您可以尝试寻找其他类型的优化。但你应该从基础开始。|1476642|例如，当前的“最快”是Jb伊维安的定位解决方案。|1476643|如果你观察它的核心|1476644|++++for+(int+i+=+0;+i+<+self.Length;+i%2B%2B)+{
++++++++++++if+(!IsMatch+(self,+i,+candidate))
++++++++++++++++++++continue;

++++++++++++list.Add+(i);
++++}|code-block|syntax|javascript|1476645|对子算法进行匹配后，它将在i%2B+1处开始查找匹配，但您已经知道第一个可能的匹配将是i%2B+candidate.Length。所以如果你加上，|1476646|i+%2B=+candidate.Length+-2;+//++-2+instead+of+-1+because+the+i%2B%2B+will+add+the+last+index|1476647|当你期望该子集在超集中大量出现时，它会快得多。(Bruno+Conde已经在他的解决方案中做到了这一点)|1476648|但这只是KNP算法的一半，您还应该向名为numberOfValidMatches的IsMatch方法添加一个额外的参数，该参数将是out参数。|1476649|这将解析为以下内容：|1476650|int+validMatches+=+0;
if+(!IsMatch+(self,+i,+candidate,+out+validMatches))
{
++++i+%2B=+validMatches+-+1;+//+-1+because+the+i%2B%2B+will+do+the+last+one
++++continue;
}|1476651|和|1476652|static+bool+IsMatch+(byte+[]+array,+int+position,+byte+[]+candidate,+out+int+numberOfValidMatches)
{
++++numberOfValidMatches+=+0;
++++if+(candidate.Length+>+(array.Length+-+position))
++++++++++++return+false;

++++for+(i+=+0;+i+<+candidate.Length;+i%2B%2B)
++++{
++++++++++++if+(array+[position+%2B+i]+!=+candidate+[i])
++++++++++++++++++++return+false;
++++++++++++numberOfValidMatches%2B%2B;+
++++}

++++return+true;
}|1476653|稍微重构一下，您就可以使用numberOfValidMatches作为循环变量，并使用while重写Locate循环以避免-2和-1。但我只是想弄清楚如何添加KMP算法。|1476654|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Knuth%25E2%2580%2593Morris%25E2%2580%2593Pratt_algorithm|1|http://en.wikipedia.org/wiki/Boyer%25E2%2580%2593Moore_string_search_algorithm^0|0|9|12|0|2A|B|1|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1J|8|@]|9|@$D|1K|E|1L|1|1M]|$D|1N|E|1O|1|1P]]|A|$]]|$1|F|3|G|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1S|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|1T|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|1U|8|@]|9|@]|A|$]]|$1|S|3|T|5|N|7|1V|8|@]|9|@]|A|$O|P]]|$1|U|3|V|5|6|7|1W|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1X|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|10|3|11|5|N|7|1Z|8|@]|9|@]|A|$O|P]]|$1|12|3|13|5|6|7|20|8|@]|9|@]|A|$]]|$1|14|3|15|5|N|7|21|8|@]|9|@]|A|$O|P]]|$1|16|3|17|5|6|7|22|8|@]|9|@]|A|$]]|$1|18|3|-4|5|6|7|23|8|@]|9|@]|A|$]]]|19|$1A|$5|1B|1C|1D|A|$1E|1F]]|1G|$5|1B|1C|1D|A|$1E|1H]]]]

I would use a solution which does matching by converting to a string...

You should write a simple function implementing the <a href="http://en.wikipedia.org/wiki/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm" rel="nofollow noreferrer">Knuth-Morris-Pratt searching algorithm</a>. This will be the fastest simple algorithm you can use to find the correct indexes.(You could use <a href="http://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string_search_algorithm" rel="nofollow noreferrer">Boyer-Moore</a> but it will require more setup.

After you have optimized the algorithm, you could try to look for other kind of optimizations. But you should start with the basics.

For example, the current "fastest" is the Locate solution by Jb Evian.

if you look at the core

<pre><code> for (int i = 0; i &lt; self.Length; i++) {
 if (!IsMatch (self, i, candidate))
 continue;

 list.Add (i);
 }
</code></pre>

After a match of the sub algorithm, it will start to find a match at i + 1, but you already know that the first possible match would be i + candidate.Length. So if you add,

<pre><code>i += candidate.Length -2; // -2 instead of -1 because the i++ will add the last index
</code></pre>

it will be a lot faster when you expect a lot of occurrences of the subset in the superset. (Bruno Conde already does this in his solution)

But this is just a half of the KNP algorithm, you should also add an extra parameter to the IsMatch method called numberOfValidMatches which would be an out parameter.

this would resolve to the following:

<pre><code>int validMatches = 0;
if (!IsMatch (self, i, candidate, out validMatches))
{
 i += validMatches - 1; // -1 because the i++ will do the last one
 continue;
}
</code></pre>

and

<pre><code>static bool IsMatch (byte [] array, int position, byte [] candidate, out int numberOfValidMatches)
{
 numberOfValidMatches = 0;
 if (candidate.Length &gt; (array.Length - position))
 return false;

 for (i = 0; i &lt; candidate.Length; i++)
 {
 if (array [position + i] != candidate [i])
 return false;
 numberOfValidMatches++; 
 }

 return true;
}
</code></pre>

A little bit of refactoring and you could use the numberOfValidMatches as the loop variable, and rewrite the Locate loop using a while to avoid the -2 and -1. But I just wanted to make clear how you could add the KMP algorithm.

blocks|key|1476716|text|使用高效的Boyer-Moore+algorithm。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1476717|它的设计目的是查找包含字符串的字符串，但您只需很少的想象力就可以将其映射到字节数组。|1476718|一般来说，最佳答案是:使用您喜欢的任何字符串搜索算法:)。|1476719|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Boyer%25E2%2580%2593Moore_string_search_algorithm^0|5|L|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

Use the efficient <a href="http://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string_search_algorithm" rel="noreferrer">Boyer-Moore algorithm</a>. 

It's designed to find strings withing strings but you need little imagination to project this to byte arrays.

In general the best answer is: use any string searching algorithm that you like :).

blocks|key|1476800|text|我已经使用我的答案和Alnitak的答案中的提示创建了一个新函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1476801|public+static+List<Int32>+LocateSubset(Byte[]+superSet,+Byte[]+subSet)
{
++++if+((superSet+==+null)+%7C%7C+(subSet+==+null))
++++{
+++++++throw+new+ArgumentNullException();
++++}
++++if+((superSet.Length+<+subSet.Length)+%7C%7C+(superSet.Length+==+0)+%7C%7C+(subSet.Length+==+0))
++++{
++++++++return+new+List<Int32>();
++++}
++++var+result+=+new+List<Int32>();
++++Int32+currentIndex+=+0;
++++Int32+maxIndex+=++superSet.Length+-+subSet.Length;
++++while+(currentIndex+<+maxIndex)
++++{
+++++++++Int32+matchCount+=+CountMatches(superSet,+currentIndex,+subSet);
+++++++++if+(matchCount+==++subSet.Length)
+++++++++{
++++++++++++result.Add(currentIndex);
+++++++++}
+++++++++currentIndex%2B%2B;
+++++++++if+(matchCount+>+0)
+++++++++{
++++++++++++currentIndex+%2B=+matchCount+-+1;
+++++++++}
++++}
++++return+result;
}

private+static+Int32+CountMatches(Byte[]+superSet,+int+startIndex,+Byte[]+subSet)
{
++++Int32+currentOffset+=+0;
++++while+(currentOffset+<+subSet.Length)
++++{
++++++++if+(superSet[startIndex+%2B+currentOffset]+!=+subSet[currentOffset])
++++++++{
++++++++++++break;
++++++++}
++++++++currentOffset%2B%2B;
++++}
++++return+currentOffset;
}|code-block|syntax|javascript|1476802|我唯一不满意的部分是|1476803|+++++++++currentIndex%2B%2B;
+++++++++if+(matchCount+>+0)
+++++++++{
++++++++++++currentIndex+%2B=+matchCount+-+1;
+++++++++}|1476804|部分..。我想使用if+else来避免-1，但这会导致更好的分支预测(尽管我不确定它会有那么大的影响)。|1476805|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I've created a new function using the tips from my answer and the answer by Alnitak.

<pre><code>public static List&lt;Int32&gt; LocateSubset(Byte[] superSet, Byte[] subSet)
{
 if ((superSet == null) || (subSet == null))
 {
 throw new ArgumentNullException();
 }
 if ((superSet.Length &lt; subSet.Length) || (superSet.Length == 0) || (subSet.Length == 0))
 {
 return new List&lt;Int32&gt;();
 }
 var result = new List&lt;Int32&gt;();
 Int32 currentIndex = 0;
 Int32 maxIndex = superSet.Length - subSet.Length;
 while (currentIndex &lt; maxIndex)
 {
 Int32 matchCount = CountMatches(superSet, currentIndex, subSet);
 if (matchCount == subSet.Length)
 {
 result.Add(currentIndex);
 }
 currentIndex++;
 if (matchCount &gt; 0)
 {
 currentIndex += matchCount - 1;
 }
 }
 return result;
}

private static Int32 CountMatches(Byte[] superSet, int startIndex, Byte[] subSet)
{
 Int32 currentOffset = 0;
 while (currentOffset &lt; subSet.Length)
 {
 if (superSet[startIndex + currentOffset] != subSet[currentOffset])
 {
 break;
 }
 currentOffset++;
 }
 return currentOffset;
}
</code></pre>

the only part I'm not so happy about is the

<pre><code> currentIndex++;
 if (matchCount &gt; 0)
 {
 currentIndex += matchCount - 1;
 }
</code></pre>

part... I would have like to use a if else to avoid the -1, but this results in a better branch prediction (although I'm not that sure it will matter that much)..

blocks|key|1691968|text|谢谢你抽出时间来..。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1691969|这是我在提问之前使用/测试的代码……我问这个问题的原因是我确定我没有使用最优的代码来做这件事。再次感谢您抽出宝贵的时间！|1691970|+++private+static+int+CountPatternMatches(byte[]+pattern,+byte[]+bytes)
+++{
++++++++int+counter+=+0;

++++++++for+(int+i+=+0;+i+<+bytes.Length;+i%2B%2B)
++++++++{
++++++++++++if+(bytes[i]+==+pattern[0]+&&+(i+%2B+pattern.Length)+<+bytes.Length)
++++++++++++{
++++++++++++++++for+(int+x+=+1;+x+<+pattern.Length;+x%2B%2B)
++++++++++++++++{
++++++++++++++++++++if+(pattern[x]+!=+bytes[x%2Bi])
++++++++++++++++++++{
++++++++++++++++++++++++break;
++++++++++++++++++++}

++++++++++++++++++++if+(x+==+pattern.Length+-1)
++++++++++++++++++++{
++++++++++++++++++++++++counter%2B%2B;
++++++++++++++++++++++++i+=+i+%2B+pattern.Length;
++++++++++++++++++++}
++++++++++++++++}
++++++++++++}
++++++++}

++++++++return+counter;
++++}|code-block|syntax|javascript|1691971|有没有人在我的代码中发现了错误？这被认为是一种黑客方法吗？我几乎尝试了你们发布的每一个样本，我似乎在比赛结果中得到了一些变化。我一直使用~10Mb字节数组作为我的toBeSearched数组来运行我的测试。|1691972|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

thanks for taking the time...

This is the code that i was using/testing with before I asked my question...
The reason I ask this question was that I´m certain of that I´m not using the optimal code to do this... so thanks again for taking the time!

<pre><code> private static int CountPatternMatches(byte[] pattern, byte[] bytes)
 {
 int counter = 0;

 for (int i = 0; i &lt; bytes.Length; i++)
 {
 if (bytes[i] == pattern[0] &amp;&amp; (i + pattern.Length) &lt; bytes.Length)
 {
 for (int x = 1; x &lt; pattern.Length; x++)
 {
 if (pattern[x] != bytes[x+i])
 {
 break;
 }

 if (x == pattern.Length -1)
 {
 counter++;
 i = i + pattern.Length;
 }
 }
 }
 }

 return counter;
 }
</code></pre>

Anyone that see any errors in my code? Is this considered as an hackish approach?
I have tried almost every sample you guys have posted and I seems to get some variations in the match results. I have been running my tests with ~10Mb byte array as my toBeSearched array.

blocks|key|1476924|text|速度并不代表一切。你有没有检查它们的一致性？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1476925|我没有测试这里列出的所有代码。我测试了我自己的代码(我承认这不是完全一致的)和IndexOfSequence。我发现在许多测试中，IndexOfSequence比我的代码要快得多，但通过反复测试，我发现它的一致性较差。特别是，它似乎在数组末尾查找模式时遇到了最大的麻烦，但有时它也会在数组中间找不到它们。|1476926|我的测试代码不是为提高效率而设计的，我只是想要有一堆随机数据，其中包含一些已知的字符串。该测试模式大致类似于http表单上传流中的边界标记。当我遇到这段代码时，这就是我要寻找的，所以我想我应该用我要搜索的数据来测试它。看起来，模式越长，IndexOfSequence错过值的可能性就越大。|1476927|private+static+void+TestMethod()
{
++++Random+rnd+=+new+Random(DateTime.Now.Millisecond);
++++string+Pattern+=+"-------------------------------65498495198498";
++++byte[]+pattern+=+Encoding.ASCII.GetBytes(Pattern);

++++byte[]+testBytes;
++++int+count+=+3;
++++for+(int+i+=+0;+i+<+100;+i%2B%2B)
++++{
++++++++StringBuilder+TestString+=+new+StringBuilder(2500);
++++++++TestString.Append(Pattern);
++++++++byte[]+buf+=+new+byte[1000];
++++++++rnd.NextBytes(buf);
++++++++TestString.Append(Encoding.ASCII.GetString(buf));
++++++++TestString.Append(Pattern);
++++++++rnd.NextBytes(buf);
++++++++TestString.Append(Encoding.ASCII.GetString(buf));
++++++++TestString.Append(Pattern);
++++++++testBytes+=+Encoding.ASCII.GetBytes(TestString.ToString());

++++++++List<int>+idx+=+IndexOfSequence(ref+testBytes,+pattern,+0);
++++++++if+(idx.Count+!=+count)
++++++++{
++++++++++++Console.Write("change+from+{0}+to+{1}+on+iteration+{2}:+",+count,+idx.Count,+i);
++++++++++++foreach+(int+ix+in+idx)
++++++++++++{
++++++++++++++++Console.Write("{0},+",+ix);
++++++++++++}
++++++++++++Console.WriteLine();
++++++++++++count+=+idx.Count;
++++++++}
++++}

++++Console.WriteLine("Press+ENTER+to+exit");
++++Console.ReadLine();
}|code-block|syntax|javascript|1476928|(显然，我将IndexOfSequence从扩展转换回了用于此测试的普通方法)|1476929|下面是我的输出示例：|1476930|change+from+3+to+2+on+iteration+1:+0,+2090,
change+from+2+to+3+on+iteration+2:+0,+1045,+2090,
change+from+3+to+2+on+iteration+3:+0,+1045,
change+from+2+to+3+on+iteration+4:+0,+1045,+2090,
change+from+3+to+2+on+iteration+6:+0,+2090,
change+from+2+to+3+on+iteration+7:+0,+1045,+2090,
change+from+3+to+2+on+iteration+11:+0,+2090,
change+from+2+to+3+on+iteration+12:+0,+1045,+2090,
change+from+3+to+2+on+iteration+14:+0,+2090,
change+from+2+to+3+on+iteration+16:+0,+1045,+2090,
change+from+3+to+2+on+iteration+17:+0,+1045,
change+from+2+to+3+on+iteration+18:+0,+1045,+2090,
change+from+3+to+1+on+iteration+20:+0,
change+from+1+to+3+on+iteration+21:+0,+1045,+2090,
change+from+3+to+2+on+iteration+22:+0,+2090,
change+from+2+to+3+on+iteration+23:+0,+1045,+2090,
change+from+3+to+2+on+iteration+24:+0,+2090,
change+from+2+to+3+on+iteration+25:+0,+1045,+2090,
change+from+3+to+2+on+iteration+26:+0,+2090,
change+from+2+to+3+on+iteration+27:+0,+1045,+2090,
change+from+3+to+2+on+iteration+43:+0,+1045,
change+from+2+to+3+on+iteration+44:+0,+1045,+2090,
change+from+3+to+2+on+iteration+48:+0,+1045,
change+from+2+to+3+on+iteration+49:+0,+1045,+2090,
change+from+3+to+2+on+iteration+50:+0,+2090,
change+from+2+to+3+on+iteration+52:+0,+1045,+2090,
change+from+3+to+2+on+iteration+54:+0,+1045,
change+from+2+to+3+on+iteration+57:+0,+1045,+2090,
change+from+3+to+2+on+iteration+62:+0,+1045,
change+from+2+to+3+on+iteration+63:+0,+1045,+2090,
change+from+3+to+2+on+iteration+72:+0,+2090,
change+from+2+to+3+on+iteration+73:+0,+1045,+2090,
change+from+3+to+2+on+iteration+75:+0,+2090,
change+from+2+to+3+on+iteration+76:+0,+1045,+2090,
change+from+3+to+2+on+iteration+78:+0,+1045,
change+from+2+to+3+on+iteration+79:+0,+1045,+2090,
change+from+3+to+2+on+iteration+81:+0,+2090,
change+from+2+to+3+on+iteration+82:+0,+1045,+2090,
change+from+3+to+2+on+iteration+85:+0,+2090,
change+from+2+to+3+on+iteration+86:+0,+1045,+2090,
change+from+3+to+2+on+iteration+89:+0,+2090,
change+from+2+to+3+on+iteration+90:+0,+1045,+2090,
change+from+3+to+2+on+iteration+91:+0,+2090,
change+from+2+to+1+on+iteration+92:+0,
change+from+1+to+3+on+iteration+93:+0,+1045,+2090,
change+from+3+to+1+on+iteration+99:+0,|1476931|我不是想找IndexOfSequence的麻烦，只是它正好是我今天开始工作的那个。在一天结束时，我注意到数据中似乎缺少模式，所以我今晚编写了自己的模式匹配器。不过，它并不是很快。在我发布之前，我将对它进行更多的调整，看看是否能达到100%25的一致性。|1476932|我只想提醒每个人，在你信任他们的产品代码之前，他们应该测试这样的东西，以确保它们能给出良好的、可重复的结果。|1476933|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|H|7|12|8|@]|9|@]|A|$I|J]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Speed isn't everything. Did you check them for consistency?

I didn't test all the code listed here. I tested my own code (which wasn't totally consistent, I admit) and IndexOfSequence. I found that for many tests IndexOfSequence was quite a bit faster than my code but with repeated testing I found that it was less consistent. In particular it seems to have the most trouble with finding patterns at the end of the array but it will miss them in the middle of the array too sometimes.

My test code isn't designed for efficiency, I just wanted to have a bunch of random data with some known strings inside. That test pattern is roughly like a boundary marker in an http form upload stream. That's what I was looking for when I ran across this code so I figured I'd test it with the kind of data I'll be searching for. It appears that the longer the pattern is the more often IndexOfSequence will miss a value.

<pre><code>private static void TestMethod()
{
 Random rnd = new Random(DateTime.Now.Millisecond);
 string Pattern = "-------------------------------65498495198498";
 byte[] pattern = Encoding.ASCII.GetBytes(Pattern);

 byte[] testBytes;
 int count = 3;
 for (int i = 0; i &lt; 100; i++)
 {
 StringBuilder TestString = new StringBuilder(2500);
 TestString.Append(Pattern);
 byte[] buf = new byte[1000];
 rnd.NextBytes(buf);
 TestString.Append(Encoding.ASCII.GetString(buf));
 TestString.Append(Pattern);
 rnd.NextBytes(buf);
 TestString.Append(Encoding.ASCII.GetString(buf));
 TestString.Append(Pattern);
 testBytes = Encoding.ASCII.GetBytes(TestString.ToString());

 List&lt;int&gt; idx = IndexOfSequence(ref testBytes, pattern, 0);
 if (idx.Count != count)
 {
 Console.Write("change from {0} to {1} on iteration {2}: ", count, idx.Count, i);
 foreach (int ix in idx)
 {
 Console.Write("{0}, ", ix);
 }
 Console.WriteLine();
 count = idx.Count;
 }
 }

 Console.WriteLine("Press ENTER to exit");
 Console.ReadLine();
}
</code></pre>

(obviously I converted IndexOfSequence from an extension back into a normal method for this testing)

Here's a sample run of my output:

<pre><code>change from 3 to 2 on iteration 1: 0, 2090,
change from 2 to 3 on iteration 2: 0, 1045, 2090,
change from 3 to 2 on iteration 3: 0, 1045,
change from 2 to 3 on iteration 4: 0, 1045, 2090,
change from 3 to 2 on iteration 6: 0, 2090,
change from 2 to 3 on iteration 7: 0, 1045, 2090,
change from 3 to 2 on iteration 11: 0, 2090,
change from 2 to 3 on iteration 12: 0, 1045, 2090,
change from 3 to 2 on iteration 14: 0, 2090,
change from 2 to 3 on iteration 16: 0, 1045, 2090,
change from 3 to 2 on iteration 17: 0, 1045,
change from 2 to 3 on iteration 18: 0, 1045, 2090,
change from 3 to 1 on iteration 20: 0,
change from 1 to 3 on iteration 21: 0, 1045, 2090,
change from 3 to 2 on iteration 22: 0, 2090,
change from 2 to 3 on iteration 23: 0, 1045, 2090,
change from 3 to 2 on iteration 24: 0, 2090,
change from 2 to 3 on iteration 25: 0, 1045, 2090,
change from 3 to 2 on iteration 26: 0, 2090,
change from 2 to 3 on iteration 27: 0, 1045, 2090,
change from 3 to 2 on iteration 43: 0, 1045,
change from 2 to 3 on iteration 44: 0, 1045, 2090,
change from 3 to 2 on iteration 48: 0, 1045,
change from 2 to 3 on iteration 49: 0, 1045, 2090,
change from 3 to 2 on iteration 50: 0, 2090,
change from 2 to 3 on iteration 52: 0, 1045, 2090,
change from 3 to 2 on iteration 54: 0, 1045,
change from 2 to 3 on iteration 57: 0, 1045, 2090,
change from 3 to 2 on iteration 62: 0, 1045,
change from 2 to 3 on iteration 63: 0, 1045, 2090,
change from 3 to 2 on iteration 72: 0, 2090,
change from 2 to 3 on iteration 73: 0, 1045, 2090,
change from 3 to 2 on iteration 75: 0, 2090,
change from 2 to 3 on iteration 76: 0, 1045, 2090,
change from 3 to 2 on iteration 78: 0, 1045,
change from 2 to 3 on iteration 79: 0, 1045, 2090,
change from 3 to 2 on iteration 81: 0, 2090,
change from 2 to 3 on iteration 82: 0, 1045, 2090,
change from 3 to 2 on iteration 85: 0, 2090,
change from 2 to 3 on iteration 86: 0, 1045, 2090,
change from 3 to 2 on iteration 89: 0, 2090,
change from 2 to 3 on iteration 90: 0, 1045, 2090,
change from 3 to 2 on iteration 91: 0, 2090,
change from 2 to 1 on iteration 92: 0,
change from 1 to 3 on iteration 93: 0, 1045, 2090,
change from 3 to 1 on iteration 99: 0,
</code></pre>

I don't mean to pick on IndexOfSequence, it just happened to be the one I started working with today. I noticed at the end of the day that it seemed to be missing patterns in the data so I wrote my own pattern matcher tonight. It's not as fast though. I'm going to tweak it a bit more to see if I can get it 100% consistent before I post it.

I just wanted to remind everyone that they should test things like this to make sure they give good, repeatable results before you trust them in production code.

blocks|key|1476989|text|我尝试了各种解决方案，最终修改了SearchBytePattern解决方案。我在一个30k的序列上进行了测试，它很快:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1476990|++++static+public+int+SearchBytePattern(byte[]+pattern,+byte[]+bytes)
++++{
++++++++int+matches+=+0;
++++++++for+(int+i+=+0;+i+<+bytes.Length;+i%2B%2B)
++++++++{
++++++++++++if+(pattern[0]+==+bytes[i]+&&+bytes.Length+-+i+>=+pattern.Length)
++++++++++++{
++++++++++++++++bool+ismatch+=+true;
++++++++++++++++for+(int+j+=+1;+j+<+pattern.Length+&&+ismatch+==+true;+j%2B%2B)
++++++++++++++++{
++++++++++++++++++++if+(bytes[i+%2B+j]+!=+pattern[j])
++++++++++++++++++++++++ismatch+=+false;
++++++++++++++++}
++++++++++++++++if+(ismatch)
++++++++++++++++{
++++++++++++++++++++matches%2B%2B;
++++++++++++++++++++i+%2B=+pattern.Length+-+1;
++++++++++++++++}
++++++++++++}
++++++++}
++++++++return+matches;
++++}|code-block|syntax|javascript|1476991|让我知道你的想法。|1476992|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I tried various solutions and ended up modifying the SearchBytePattern one. I tested on a 30k sequence and it is, fast :)

<pre><code> static public int SearchBytePattern(byte[] pattern, byte[] bytes)
 {
 int matches = 0;
 for (int i = 0; i &lt; bytes.Length; i++)
 {
 if (pattern[0] == bytes[i] &amp;&amp; bytes.Length - i &gt;= pattern.Length)
 {
 bool ismatch = true;
 for (int j = 1; j &lt; pattern.Length &amp;&amp; ismatch == true; j++)
 {
 if (bytes[i + j] != pattern[j])
 ismatch = false;
 }
 if (ismatch)
 {
 matches++;
 i += pattern.Length - 1;
 }
 }
 }
 return matches;
 }
</code></pre>

Let me know your thoughts.

blocks|key|1477053|text|这些是您可以使用的最简单、最快的方法，没有比这些更快的方法了。这是不安全的，但这就是我们使用指针来提高速度的原因。因此，在这里，我提供了我的扩展方法，我使用搜索单个，以及出现的索引列表。我想说这是这里最干净的代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1477054|++++public+static+unsafe+long+IndexOf(this+byte[]+Haystack,+byte[]+Needle)
++++{
++++++++fixed+(byte*+H+=+Haystack)+fixed+(byte*+N+=+Needle)
++++++++{
++++++++++++long+i+=+0;
++++++++++++for+(byte*+hNext+=+H,+hEnd+=+H+%2B+Haystack.LongLength;+hNext+<+hEnd;+i%2B%2B,+hNext%2B%2B)
++++++++++++{
++++++++++++++++bool+Found+=+true;
++++++++++++++++for+(byte*+hInc+=+hNext,+nInc+=+N,+nEnd+=+N+%2B+Needle.LongLength;+Found+&&+nInc+<+nEnd;+Found+=+*nInc+==+*hInc,+nInc%2B%2B,+hInc%2B%2B)+;
++++++++++++++++if+(Found)+return+i;
++++++++++++}
++++++++++++return+-1;
++++++++}
++++}
++++public+static+unsafe+List<long>+IndexesOf(this+byte[]+Haystack,+byte[]+Needle)
++++{
++++++++List<long>+Indexes+=+new+List<long>();
++++++++fixed+(byte*+H+=+Haystack)+fixed+(byte*+N+=+Needle)
++++++++{
++++++++++++long+i+=+0;
++++++++++++for+(byte*+hNext+=+H,+hEnd+=+H+%2B+Haystack.LongLength;+hNext+<+hEnd;+i%2B%2B,+hNext%2B%2B)
++++++++++++{
++++++++++++++++bool+Found+=+true;
++++++++++++++++for+(byte*+hInc+=+hNext,+nInc+=+N,+nEnd+=+N+%2B+Needle.LongLength;+Found+&&+nInc+<+nEnd;+Found+=+*nInc+==+*hInc,+nInc%2B%2B,+hInc%2B%2B)+;
++++++++++++++++if+(Found)+Indexes.Add(i);
++++++++++++}
++++++++++++return+Indexes;
++++++++}
++++}|code-block|syntax|javascript|1477055|通过使用Locate进行基准测试，速度提高了1.2-1.4倍|1477056|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

These are the simplest and fastest methods you can use, and there wouldn't be anything faster than these. It is unsafe but that's what we use pointers for is speed. So here I offer you my extension methods that I use search for a single, and a list of indices of the occurrences. I would like to say this is the cleanest code here.

<pre><code> public static unsafe long IndexOf(this byte[] Haystack, byte[] Needle)
 {
 fixed (byte* H = Haystack) fixed (byte* N = Needle)
 {
 long i = 0;
 for (byte* hNext = H, hEnd = H + Haystack.LongLength; hNext &lt; hEnd; i++, hNext++)
 {
 bool Found = true;
 for (byte* hInc = hNext, nInc = N, nEnd = N + Needle.LongLength; Found &amp;&amp; nInc &lt; nEnd; Found = *nInc == *hInc, nInc++, hInc++) ;
 if (Found) return i;
 }
 return -1;
 }
 }
 public static unsafe List&lt;long&gt; IndexesOf(this byte[] Haystack, byte[] Needle)
 {
 List&lt;long&gt; Indexes = new List&lt;long&gt;();
 fixed (byte* H = Haystack) fixed (byte* N = Needle)
 {
 long i = 0;
 for (byte* hNext = H, hEnd = H + Haystack.LongLength; hNext &lt; hEnd; i++, hNext++)
 {
 bool Found = true;
 for (byte* hInc = hNext, nInc = N, nEnd = N + Needle.LongLength; Found &amp;&amp; nInc &lt; nEnd; Found = *nInc == *hInc, nInc++, hInc++) ;
 if (Found) Indexes.Add(i);
 }
 return Indexes;
 }
 }
</code></pre>

Benchmarked with Locate, it is 1.2-1.4x faster

blocks|key|1692231|text|这是我想出的一个解决方案。我在实现过程中发现了一些注释。它可以匹配向前、向后和不同(+in+/dec)还款额，例如方向；从干草堆中的任何偏移量开始。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1692232|任何输入都是很棒的！|1692233|++++///+<summary>
++++///+Matches+a+byte+array+to+another+byte+array
++++///+forwards+or+reverse
++++///+</summary>
++++///+<param+name="a">byte+array</param>
++++///+<param+name="offset">start+offset</param>
++++///+<param+name="len">max+length</param>
++++///+<param+name="b">byte+array</param>
++++///+<param+name="direction">to+move+each+iteration</param>
++++///+<returns>true+if+all+bytes+match,+otherwise+false</returns>
++++internal+static+bool+Matches(ref+byte[]+a,+int+offset,+int+len,+ref+byte[]+b,+int+direction+=+1)
++++{
++++++++#region+Only+Matched+from+offset+Within+a+and+b,+could+not+differ,+e.g.+if+you+wanted+to+mach+in+reverse+for+only+part+of+a+in+some+of+b+that+would+not+work
++++++++//if+(direction+==+0)+throw+new+ArgumentException("direction");
++++++++//for+(;+offset+<+len;+offset+%2B=+direction)+if+(a[offset]+!=+b[offset])+return+false;
++++++++//return+true;
++++++++#endregion
++++++++//Will+match+if+b+contains+len+of+a+and+return+a+a+index+of+positive+value
++++++++return+IndexOfBytes(ref+a,+ref+offset,+len,+ref+b,+len)+!=+-1;
++++}

///Here+is+the+Implementation+code

++++///+<summary>
++++///+Swaps+two+integers+without+using+a+temporary+variable
++++///+</summary>
++++///+<param+name="a"></param>
++++///+<param+name="b"></param>
++++internal+static+void+Swap(ref+int+a,+ref+int+b)
++++{
++++++++a+%5E=+b;
++++++++b+%5E=+a;
++++++++a+%5E=+b;
++++}

++++///+<summary>
++++///+Swaps+two+bytes+without+using+a+temporary+variable
++++///+</summary>
++++///+<param+name="a"></param>
++++///+<param+name="b"></param>
++++internal+static+void+Swap(ref+byte+a,+ref+byte+b)
++++{
++++++++a+%5E=+b;
++++++++b+%5E=+a;
++++++++a+%5E=+b;
++++}

++++///+<summary>
++++///+Can+be+used+to+find+if+a+array+starts,+ends+spot+Matches+or+compltely+contains+a+sub+byte+array
++++///+Set+checkLength+to+the+amount+of+bytes+from+the+needle+you+want+to+match,+start+at+0+for+forward+searches+start+at+hayStack.Lenght+-1+for+reverse+matches
++++///+</summary>
++++///+<param+name="a">Needle</param>
++++///+<param+name="offset">Start+in+Haystack</param>
++++///+<param+name="len">Length+of+required+match</param>
++++///+<param+name="b">Haystack</param>
++++///+<param+name="direction">Which+way+to+move+the+iterator</param>
++++///+<returns>Index+if+found,+otherwise+-1</returns>
++++internal+static+int+IndexOfBytes(ref+byte[]+needle,+ref+int+offset,+int+checkLength,+ref+byte[]+haystack,+int+direction+=+1)
++++{
++++++++//If+the+direction+is+==+0+we+would+spin+forever+making+no+progress
++++++++if+(direction+==+0)+throw+new+ArgumentException("direction");
++++++++//Cache+the+length+of+the+needle+and+the+haystack,+setup+the+endIndex+for+a+reverse+search
++++++++int+needleLength+=+needle.Length,+haystackLength+=+haystack.Length,+endIndex+=+0,+workingOffset+=+offset;
++++++++//Allocate+a+value+for+the+endIndex+and+workingOffset
++++++++//If+we+are+going+forward+then+the+bound+is+the+haystackLength
++++++++if+(direction+>=+1)+endIndex+=+haystackLength;
++++++++#region+[Optomization+-+Not+Required]
++++++++//{

++++++++++++//I+though+this+was+required+for+partial+matching+but+it+seems+it+is+not+needed+in+this+form
++++++++++++//workingOffset+=+needleLength+-+checkLength;
++++++++//}
++++++++#endregion
++++++++else+Swap(ref+workingOffset,+ref+endIndex);++++++++++++++++
++++++++#region+[Optomization+-+Not+Required]
++++++++//{+
++++++++++++//Otherwise+we+are+going+in+reverse+and+the+endIndex+is+the+needleLength+-+checkLength+++++++++++++++++++
++++++++++++//I+though+the+length+had+to+be+adjusted+but+it+seems+it+is+not+needed+in+this+form
++++++++++++//endIndex+=+needleLength+-+checkLength;
++++++++//}
++++++++#endregion
++++++++#region+[Optomized+to+above]
++++++++//Allocate+a+value+for+the+endIndex
++++++++//endIndex+=+direction+>=+1+?+haystackLength+:+needleLength+-+checkLength,
++++++++//Determine+the+workingOffset
++++++++//workingOffset+=+offset+>+needleLength+?+offset+:+needleLength;++++++++++++
++++++++//If+we+are+doing+in+reverse+swap+the+two
++++++++//if+(workingOffset+>+endIndex)+Swap(ref+workingOffset,+ref+endIndex);
++++++++//Else+we+are+going+in+forward+direction+do+the+offset+is+adjusted+by+the+length+of+the+check
++++++++//else+workingOffset+-=+checkLength;
++++++++//Start+at+the+checkIndex+(workingOffset)+every+search+attempt
++++++++#endregion
++++++++//Save+the+checkIndex+(used+after+the+for+loop+is+done+with+it+to+determine+if+the+match+was+checkLength+long)
++++++++int+checkIndex+=+workingOffset;
++++++++#region+[For+Loop+Version]
++++++++///Optomized+with+while+(single+op)
++++++++///for+(int+checkIndex+=+workingOffset;+checkIndex+<+endIndex;+offset+%2B=+direction,+checkIndex+=+workingOffset)
++++++++++++///{
++++++++++++++++///Start+at+the+checkIndex
++++++++++++++++///+While+the+checkIndex+<+checkLength+move+forward
++++++++++++++++///+If+NOT+(the+needle+at+the+checkIndex+matched+the+haystack+at+the+offset+%2B+checkIndex)+BREAK+ELSE+we+have+a+match+continue+the+search++++++++++++++++
++++++++++++++++///+for+(;+checkIndex+<+checkLength;+%2B%2BcheckIndex)+if+(needle[checkIndex]+!=+haystack[offset+%2B+checkIndex])+break;+else+continue;
++++++++++++++++///+If+the+match+was+the+length+of+the+check
++++++++++++++++///+if+(checkIndex+==+checkLength)+return+offset;+//We+are+done+matching
++++++++++++///}
++++++++#endregion
++++++++//While+the+checkIndex+<+endIndex
++++++++while+(checkIndex+<+endIndex)
++++++++{
++++++++++++for+(;+checkIndex+<+checkLength;+%2B%2BcheckIndex)+if+(needle[checkIndex]+!=+haystack[offset+%2B+checkIndex])+break;+else+continue;
++++++++++++//If+the+match+was+the+length+of+the+check
++++++++++++if+(checkIndex+==+checkLength)+return+offset;+//We+are+done+matching
++++++++++++//Move+the+offset+by+the+direction,+reset+the+checkIndex+to+the+workingOffset
++++++++++++offset+%2B=+direction;+checkIndex+=+workingOffset;++++++++++++++++
++++++++}
++++++++//We+did+not+have+a+match+with+the+given+options
++++++++return+-1;
++++}|code-block|syntax|javascript|1692234|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here is a solution I came up with. I included notes I found along the way with the implementation. It can match forward, backward and with different (in/dec)remement amounts e.g. direction; starting at any offset in the haystack.

Any input would be awesome!

<pre><code> /// &lt;summary&gt;
 /// Matches a byte array to another byte array
 /// forwards or reverse
 /// &lt;/summary&gt;
 /// &lt;param name="a"&gt;byte array&lt;/param&gt;
 /// &lt;param name="offset"&gt;start offset&lt;/param&gt;
 /// &lt;param name="len"&gt;max length&lt;/param&gt;
 /// &lt;param name="b"&gt;byte array&lt;/param&gt;
 /// &lt;param name="direction"&gt;to move each iteration&lt;/param&gt;
 /// &lt;returns&gt;true if all bytes match, otherwise false&lt;/returns&gt;
 internal static bool Matches(ref byte[] a, int offset, int len, ref byte[] b, int direction = 1)
 {
 #region Only Matched from offset Within a and b, could not differ, e.g. if you wanted to mach in reverse for only part of a in some of b that would not work
 //if (direction == 0) throw new ArgumentException("direction");
 //for (; offset &lt; len; offset += direction) if (a[offset] != b[offset]) return false;
 //return true;
 #endregion
 //Will match if b contains len of a and return a a index of positive value
 return IndexOfBytes(ref a, ref offset, len, ref b, len) != -1;
 }

///Here is the Implementation code

 /// &lt;summary&gt;
 /// Swaps two integers without using a temporary variable
 /// &lt;/summary&gt;
 /// &lt;param name="a"&gt;&lt;/param&gt;
 /// &lt;param name="b"&gt;&lt;/param&gt;
 internal static void Swap(ref int a, ref int b)
 {
 a ^= b;
 b ^= a;
 a ^= b;
 }

 /// &lt;summary&gt;
 /// Swaps two bytes without using a temporary variable
 /// &lt;/summary&gt;
 /// &lt;param name="a"&gt;&lt;/param&gt;
 /// &lt;param name="b"&gt;&lt;/param&gt;
 internal static void Swap(ref byte a, ref byte b)
 {
 a ^= b;
 b ^= a;
 a ^= b;
 }

 /// &lt;summary&gt;
 /// Can be used to find if a array starts, ends spot Matches or compltely contains a sub byte array
 /// Set checkLength to the amount of bytes from the needle you want to match, start at 0 for forward searches start at hayStack.Lenght -1 for reverse matches
 /// &lt;/summary&gt;
 /// &lt;param name="a"&gt;Needle&lt;/param&gt;
 /// &lt;param name="offset"&gt;Start in Haystack&lt;/param&gt;
 /// &lt;param name="len"&gt;Length of required match&lt;/param&gt;
 /// &lt;param name="b"&gt;Haystack&lt;/param&gt;
 /// &lt;param name="direction"&gt;Which way to move the iterator&lt;/param&gt;
 /// &lt;returns&gt;Index if found, otherwise -1&lt;/returns&gt;
 internal static int IndexOfBytes(ref byte[] needle, ref int offset, int checkLength, ref byte[] haystack, int direction = 1)
 {
 //If the direction is == 0 we would spin forever making no progress
 if (direction == 0) throw new ArgumentException("direction");
 //Cache the length of the needle and the haystack, setup the endIndex for a reverse search
 int needleLength = needle.Length, haystackLength = haystack.Length, endIndex = 0, workingOffset = offset;
 //Allocate a value for the endIndex and workingOffset
 //If we are going forward then the bound is the haystackLength
 if (direction &gt;= 1) endIndex = haystackLength;
 #region [Optomization - Not Required]
 //{

 //I though this was required for partial matching but it seems it is not needed in this form
 //workingOffset = needleLength - checkLength;
 //}
 #endregion
 else Swap(ref workingOffset, ref endIndex); 
 #region [Optomization - Not Required]
 //{ 
 //Otherwise we are going in reverse and the endIndex is the needleLength - checkLength 
 //I though the length had to be adjusted but it seems it is not needed in this form
 //endIndex = needleLength - checkLength;
 //}
 #endregion
 #region [Optomized to above]
 //Allocate a value for the endIndex
 //endIndex = direction &gt;= 1 ? haystackLength : needleLength - checkLength,
 //Determine the workingOffset
 //workingOffset = offset &gt; needleLength ? offset : needleLength; 
 //If we are doing in reverse swap the two
 //if (workingOffset &gt; endIndex) Swap(ref workingOffset, ref endIndex);
 //Else we are going in forward direction do the offset is adjusted by the length of the check
 //else workingOffset -= checkLength;
 //Start at the checkIndex (workingOffset) every search attempt
 #endregion
 //Save the checkIndex (used after the for loop is done with it to determine if the match was checkLength long)
 int checkIndex = workingOffset;
 #region [For Loop Version]
 ///Optomized with while (single op)
 ///for (int checkIndex = workingOffset; checkIndex &lt; endIndex; offset += direction, checkIndex = workingOffset)
 ///{
 ///Start at the checkIndex
 /// While the checkIndex &lt; checkLength move forward
 /// If NOT (the needle at the checkIndex matched the haystack at the offset + checkIndex) BREAK ELSE we have a match continue the search 
 /// for (; checkIndex &lt; checkLength; ++checkIndex) if (needle[checkIndex] != haystack[offset + checkIndex]) break; else continue;
 /// If the match was the length of the check
 /// if (checkIndex == checkLength) return offset; //We are done matching
 ///}
 #endregion
 //While the checkIndex &lt; endIndex
 while (checkIndex &lt; endIndex)
 {
 for (; checkIndex &lt; checkLength; ++checkIndex) if (needle[checkIndex] != haystack[offset + checkIndex]) break; else continue;
 //If the match was the length of the check
 if (checkIndex == checkLength) return offset; //We are done matching
 //Move the offset by the direction, reset the checkIndex to the workingOffset
 offset += direction; checkIndex = workingOffset; 
 }
 //We did not have a match with the given options
 return -1;
 }
</code></pre>

blocks|key|1692276|text|我来晚了，用Boyer+Moore算法搜索字节而不是字符串怎么样？下面是c#代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1692277|EyeCode+Inc.|1692278|class+Program+{
++++static+void+Main(string[]+args)+{
++++++++byte[]+text+++++++++=++new+byte[]+{12,3,5,76,8,0,6,125,23,36,43,76,125,56,34,234,12,4,5,76,8,0,6,125,234,56,211,122,22,4,7,89,76,64,12,3,5,76,8,0,6,123};
++++++++byte[]+pattern++++++=+new+byte[]+{12,3,5,76,8,0,6,125};

++++++++BoyerMoore+tmpSearch+=+new+BoyerMoore(pattern,text);

++++++++Console.WriteLine(tmpSearch.Match());
++++++++Console.ReadKey();
++++}

++++public+class+BoyerMoore+{

++++++++private+static+int+ALPHABET_SIZE+=+256;

++++++++private+byte[]+text;
++++++++private+byte[]+pattern;

++++++++private+int[]+last;
++++++++private+int[]+match;
++++++++private+int[]+suffix;

++++++++public+BoyerMoore(byte[]+pattern,+byte[]+text)+{
++++++++++++this.text+=+text;
++++++++++++this.pattern+=+pattern;
++++++++++++last+=+new+int[ALPHABET_SIZE];
++++++++++++match+=+new+int[pattern.Length];
++++++++++++suffix+=+new+int[pattern.Length];
++++++++}


++++++++/**
++++++++*+Searches+the+pattern+in+the+text.
++++++++*+returns+the+position+of+the+first+occurrence,+if+found+and+-1+otherwise.
++++++++*/
++++++++public+int+Match()+{
++++++++++++//+Preprocessing
++++++++++++ComputeLast();
++++++++++++ComputeMatch();

++++++++++++//+Searching
++++++++++++int+i+=+pattern.Length+-+1;
++++++++++++int+j+=+pattern.Length+-+1;++++
++++++++++++while+(i+<+text.Length)+{
++++++++++++++++if+(pattern[j]+==+text[i])+{
++++++++++++++++++++if+(j+==+0)+{+
++++++++++++++++++++++++return+i;
++++++++++++++++++++}
++++++++++++++++++++j--;
++++++++++++++++++++i--;
++++++++++++++++}+
++++++++++++++++else+{
++++++++++++++++++i+%2B=+pattern.Length+-+j+-+1+%2B+Math.Max(j+-+last[text[i]],+match[j]);
++++++++++++++++++j+=+pattern.Length+-+1;
++++++++++++++}
++++++++++++}
++++++++++++return+-1;++++
++++++++++}++


++++++++/**
++++++++*+Computes+the+function+last+and+stores+its+values+in+the+array+last.
++++++++*+last(Char+ch)+=+the+index+of+the+right-most+occurrence+of+the+character+ch
++++++++*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++in+the+pattern;+
++++++++*+++++++++++++++++-1+if+ch+does+not+occur+in+the+pattern.
++++++++*/
++++++++private+void+ComputeLast()+{
++++++++++++for+(int+k+=+0;+k+<+last.Length;+k%2B%2B)+{+
++++++++++++++++last[k]+=+-1;
++++++++++++}
++++++++++++for+(int+j+=+pattern.Length-1;+j+>=+0;+j--)+{
++++++++++++++++if+(last[pattern[j]]+<+0)+{
++++++++++++++++++++last[pattern[j]]+=+j;
++++++++++++++++}
++++++++++++}
++++++++}


++++++++/**
++++++++*+Computes+the+function+match+and+stores+its+values+in+the+array+match.
++++++++*+match(j)+=+min{+s+%7C+0+<+s+<=+j+&&+p[j-s]!=p[j]
++++++++*++++++++++++++++++++++++++++&&+p[j-s%2B1]..p[m-s-1]+is+suffix+of+p[j%2B1]..p[m-1]+},+
++++++++*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++if+such+s+exists,+else
++++++++*++++++++++++min{+s+%7C+j%2B1+<=+s+<=+m+
++++++++*++++++++++++++++++++++++++++&&+p[0]..p[m-s-1]+is+suffix+of+p[j%2B1]..p[m-1]+},+
++++++++*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++if+such+s+exists,
++++++++*++++++++++++m,+otherwise,
++++++++*+where+p+is+the+pattern+and+m+is+its+length.
++++++++*/
++++++++private+void+ComputeMatch()+{
++++++++++++/*+Phase+1+*/
++++++++++++for+(int+j+=+0;+j+<+match.Length;+j%2B%2B)+{+
++++++++++++++++match[j]+=+match.Length;
++++++++++++}+//O(m)+

++++++++++++ComputeSuffix();+//O(m)

++++++++++++/*+Phase+2+*/
++++++++++++//Uses+an+auxiliary+array,+backwards+version+of+the+KMP+failure+function.
++++++++++++//suffix[i]+=+the+smallest+j+>+i+s.t.+p[j..m-1]+is+a+prefix+of+p[i..m-1],
++++++++++++//if+there+is+no+such+j,+suffix[i]+=+m

++++++++++++//Compute+the+smallest+shift+s,+such+that+0+<+s+<=+j+and
++++++++++++//p[j-s]!=p[j]+and+p[j-s%2B1..m-s-1]+is+suffix+of+p[j%2B1..m-1]+or+j+==+m-1},+
++++++++++++//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++if+such+s+exists,
++++++++++++for+(int+i+=+0;+i+<+match.Length+-+1;+i%2B%2B)+{
++++++++++++++++int+j+=+suffix[i+%2B+1]+-+1;+//+suffix[i%2B1]+<=+suffix[i]+%2B+1
++++++++++++++++if+(suffix[i]+>+j)+{+//+therefore+pattern[i]+!=+pattern[j]
++++++++++++++++++++match[j]+=+j+-+i;
++++++++++++++++}+
++++++++++++++++else+{//+j+==+suffix[i]
++++++++++++++++++++match[j]+=+Math.Min(j+-+i+%2B+match[i],+match[j]);
++++++++++++++++}
++++++++++++}

++++++++++++/*+Phase+3+*/
++++++++++++//Uses+the+suffix+array+to+compute+each+shift+s+such+that
++++++++++++//p[0..m-s-1]+is+a+suffix+of+p[j%2B1..m-1]+with+j+<+s+<+m
++++++++++++//and+stores+the+minimum+of+this+shift+and+the+previously+computed+one.
++++++++++++if+(suffix[0]+<+pattern.Length)+{
++++++++++++++++for+(int+j+=+suffix[0]+-+1;+j+>=+0;+j--)+{
++++++++++++++++++++if+(suffix[0]+<+match[j])+{+match[j]+=+suffix[0];+}
++++++++++++++++}
++++++++++++++++{
++++++++++++++++++++int+j+=+suffix[0];
++++++++++++++++++++for+(int+k+=+suffix[j];+k+<+pattern.Length;+k+=+suffix[k])+{
++++++++++++++++++++++++while+(j+<+k)+{
++++++++++++++++++++++++++++if+(match[j]+>+k)+{
++++++++++++++++++++++++++++++++match[j]+=+k;
++++++++++++++++++++++++++++}
++++++++++++++++++++++++++++j%2B%2B;
++++++++++++++++++++++++}
++++++++++++++++++++}
++++++++++++++++}
++++++++++++}
++++++++}


++++++++/**
++++++++*+Computes+the+values+of+suffix,+which+is+an+auxiliary+array,+
++++++++*+backwards+version+of+the+KMP+failure+function.
++++++++*+
++++++++*+suffix[i]+=+the+smallest+j+>+i+s.t.+p[j..m-1]+is+a+prefix+of+p[i..m-1],
++++++++*+if+there+is+no+such+j,+suffix[i]+=+m,+i.e.+

++++++++*+p[suffix[i]..m-1]+is+the+longest+prefix+of+p[i..m-1],+if+suffix[i]+<+m.
++++++++*/
++++++++private+void+ComputeSuffix()+{++++++++
++++++++++++suffix[suffix.Length-1]+=+suffix.Length;++++++++++++
++++++++++++int+j+=+suffix.Length+-+1;
++++++++++++for+(int+i+=+suffix.Length+-+2;+i+>=+0;+i--)+{++
++++++++++++++++while+(j+<+suffix.Length+-+1+&&+!pattern[j].Equals(pattern[i]))+{
++++++++++++++++++++j+=+suffix[j+%2B+1]+-+1;
++++++++++++++++}
++++++++++++++++if+(pattern[j]+==+pattern[i])+{+
++++++++++++++++++++j--;+
++++++++++++++++}
++++++++++++++++suffix[i]+=+j+%2B+1;
++++++++++++}
++++++++}

++++}

}|code-block|syntax|javascript|1692279|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I'm a little late to the party
How about using Boyer Moore algorithm but search for bytes instead of strings.
c# code below.

EyeCode Inc.

<pre><code>class Program {
 static void Main(string[] args) {
 byte[] text = new byte[] {12,3,5,76,8,0,6,125,23,36,43,76,125,56,34,234,12,4,5,76,8,0,6,125,234,56,211,122,22,4,7,89,76,64,12,3,5,76,8,0,6,123};
 byte[] pattern = new byte[] {12,3,5,76,8,0,6,125};

 BoyerMoore tmpSearch = new BoyerMoore(pattern,text);

 Console.WriteLine(tmpSearch.Match());
 Console.ReadKey();
 }

 public class BoyerMoore {

 private static int ALPHABET_SIZE = 256;

 private byte[] text;
 private byte[] pattern;

 private int[] last;
 private int[] match;
 private int[] suffix;

 public BoyerMoore(byte[] pattern, byte[] text) {
 this.text = text;
 this.pattern = pattern;
 last = new int[ALPHABET_SIZE];
 match = new int[pattern.Length];
 suffix = new int[pattern.Length];
 }


 /**
 * Searches the pattern in the text.
 * returns the position of the first occurrence, if found and -1 otherwise.
 */
 public int Match() {
 // Preprocessing
 ComputeLast();
 ComputeMatch();

 // Searching
 int i = pattern.Length - 1;
 int j = pattern.Length - 1; 
 while (i &lt; text.Length) {
 if (pattern[j] == text[i]) {
 if (j == 0) { 
 return i;
 }
 j--;
 i--;
 } 
 else {
 i += pattern.Length - j - 1 + Math.Max(j - last[text[i]], match[j]);
 j = pattern.Length - 1;
 }
 }
 return -1; 
 } 


 /**
 * Computes the function last and stores its values in the array last.
 * last(Char ch) = the index of the right-most occurrence of the character ch
 * in the pattern; 
 * -1 if ch does not occur in the pattern.
 */
 private void ComputeLast() {
 for (int k = 0; k &lt; last.Length; k++) { 
 last[k] = -1;
 }
 for (int j = pattern.Length-1; j &gt;= 0; j--) {
 if (last[pattern[j]] &lt; 0) {
 last[pattern[j]] = j;
 }
 }
 }


 /**
 * Computes the function match and stores its values in the array match.
 * match(j) = min{ s | 0 &lt; s &lt;= j &amp;&amp; p[j-s]!=p[j]
 * &amp;&amp; p[j-s+1]..p[m-s-1] is suffix of p[j+1]..p[m-1] }, 
 * if such s exists, else
 * min{ s | j+1 &lt;= s &lt;= m 
 * &amp;&amp; p[0]..p[m-s-1] is suffix of p[j+1]..p[m-1] }, 
 * if such s exists,
 * m, otherwise,
 * where p is the pattern and m is its length.
 */
 private void ComputeMatch() {
 /* Phase 1 */
 for (int j = 0; j &lt; match.Length; j++) { 
 match[j] = match.Length;
 } //O(m) 

 ComputeSuffix(); //O(m)

 /* Phase 2 */
 //Uses an auxiliary array, backwards version of the KMP failure function.
 //suffix[i] = the smallest j &gt; i s.t. p[j..m-1] is a prefix of p[i..m-1],
 //if there is no such j, suffix[i] = m

 //Compute the smallest shift s, such that 0 &lt; s &lt;= j and
 //p[j-s]!=p[j] and p[j-s+1..m-s-1] is suffix of p[j+1..m-1] or j == m-1}, 
 // if such s exists,
 for (int i = 0; i &lt; match.Length - 1; i++) {
 int j = suffix[i + 1] - 1; // suffix[i+1] &lt;= suffix[i] + 1
 if (suffix[i] &gt; j) { // therefore pattern[i] != pattern[j]
 match[j] = j - i;
 } 
 else {// j == suffix[i]
 match[j] = Math.Min(j - i + match[i], match[j]);
 }
 }

 /* Phase 3 */
 //Uses the suffix array to compute each shift s such that
 //p[0..m-s-1] is a suffix of p[j+1..m-1] with j &lt; s &lt; m
 //and stores the minimum of this shift and the previously computed one.
 if (suffix[0] &lt; pattern.Length) {
 for (int j = suffix[0] - 1; j &gt;= 0; j--) {
 if (suffix[0] &lt; match[j]) { match[j] = suffix[0]; }
 }
 {
 int j = suffix[0];
 for (int k = suffix[j]; k &lt; pattern.Length; k = suffix[k]) {
 while (j &lt; k) {
 if (match[j] &gt; k) {
 match[j] = k;
 }
 j++;
 }
 }
 }
 }
 }


 /**
 * Computes the values of suffix, which is an auxiliary array, 
 * backwards version of the KMP failure function.
 * 
 * suffix[i] = the smallest j &gt; i s.t. p[j..m-1] is a prefix of p[i..m-1],
 * if there is no such j, suffix[i] = m, i.e. 

 * p[suffix[i]..m-1] is the longest prefix of p[i..m-1], if suffix[i] &lt; m.
 */
 private void ComputeSuffix() { 
 suffix[suffix.Length-1] = suffix.Length; 
 int j = suffix.Length - 1;
 for (int i = suffix.Length - 2; i &gt;= 0; i--) { 
 while (j &lt; suffix.Length - 1 &amp;&amp; !pattern[j].Equals(pattern[i])) {
 j = suffix[j + 1] - 1;
 }
 if (pattern[j] == pattern[i]) { 
 j--; 
 }
 suffix[i] = j + 1;
 }
 }

 }

}
</code></pre>

blocks|key|1692293|text|下面是我仅使用基本数据类型编写的简单代码：(它返回第一次出现的索引)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1692294|private+static+int+findMatch(byte[]+data,+byte[]+pattern)+{
++++if(pattern.length+>+data.length){
++++++++return+-1;
++++}
++++for(int+i+=+0;+i<data.length+;){
++++++++int+j;
+++++++for(j=0;j<pattern.length;j%2B%2B){

+++++++++++if(pattern[j]!=data[i])
+++++++++++++++break;
+++++++++++i%2B%2B;
+++++++}
+++++++if(j==pattern.length){
+++++++++++System.out.println("Pattern+found+at+:+"%2B(i+-+pattern.length+));
+++++++++++return+i+-+pattern.length+;
+++++++}
+++++++if(j!=0)continue;
+++++++i%2B%2B;
++++}

++++return+-1;
}|code-block|syntax|javascript|1692295|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a simple code i wrote using only basic data types:
(It returns the index of first occurance) 

<pre><code>private static int findMatch(byte[] data, byte[] pattern) {
 if(pattern.length &gt; data.length){
 return -1;
 }
 for(int i = 0; i&lt;data.length ;){
 int j;
 for(j=0;j&lt;pattern.length;j++){

 if(pattern[j]!=data[i])
 break;
 i++;
 }
 if(j==pattern.length){
 System.out.println("Pattern found at : "+(i - pattern.length ));
 return i - pattern.length ;
 }
 if(j!=0)continue;
 i++;
 }

 return -1;
}
</code></pre>

blocks|key|1477212|text|我缺少LINQ方法/答案:-)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1477213|///+<summary>
///+Searches+in+the+haystack+array+for+the+given+needle+using+the+default+equality+operator+and+returns+the+index+at+which+the+needle+starts.
///+</summary>
///+<typeparam+name="T">Type+of+the+arrays.</typeparam>
///+<param+name="haystack">Sequence+to+operate+on.</param>
///+<param+name="needle">Sequence+to+search+for.</param>
///+<returns>Index+of+the+needle+within+the+haystack+or+-1+if+the+needle+isn't+contained.</returns>
public+static+IEnumerable<int>+IndexOf<T>(this+T[]+haystack,+T[]+needle)
{
++++if+((needle+!=+null)+&&+(haystack.Length+>=+needle.Length))
++++{
++++++++for+(int+l+=+0;+l+<+haystack.Length+-+needle.Length+%2B+1;+l%2B%2B)
++++++++{
++++++++++++if+(!needle.Where((data,+index)+=>+!haystack[l+%2B+index].Equals(data)).Any())
++++++++++++{
++++++++++++++++yield+return+l;
++++++++++++}
++++++++}
++++}
}|code-block|syntax|javascript|1477214|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I was missing a LINQ method/answer :-)

<pre><code>/// &lt;summary&gt;
/// Searches in the haystack array for the given needle using the default equality operator and returns the index at which the needle starts.
/// &lt;/summary&gt;
/// &lt;typeparam name="T"&gt;Type of the arrays.&lt;/typeparam&gt;
/// &lt;param name="haystack"&gt;Sequence to operate on.&lt;/param&gt;
/// &lt;param name="needle"&gt;Sequence to search for.&lt;/param&gt;
/// &lt;returns&gt;Index of the needle within the haystack or -1 if the needle isn't contained.&lt;/returns&gt;
public static IEnumerable&lt;int&gt; IndexOf&lt;T&gt;(this T[] haystack, T[] needle)
{
 if ((needle != null) &amp;&amp; (haystack.Length &gt;= needle.Length))
 {
 for (int l = 0; l &lt; haystack.Length - needle.Length + 1; l++)
 {
 if (!needle.Where((data, index) =&gt; !haystack[l + index].Equals(data)).Any())
 {
 yield return l;
 }
 }
 }
}
</code></pre>

blocks|key|1477264|text|这只是另一个答案，对于O(n)类型的操作来说，它很容易理解，并且非常有效，而不使用不安全的代码或复制源数组的一部分。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1477265|一定要进行测试。在这个主题上找到的一些建议很容易受到一些情况的影响。|1477266|++++static+void+Main(string[]+args)
++++{
++++++++//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++1+++1++1++1++1++1++1++1++1++1++2+++2+++2
++++++++//+++++++++++++++++++++++++++0++1++2++3++4++5++6++7++8++9++0+++1++2++3++4++5++6++7++8++9++0+++1+++2++3++4++5++6++7++8++9
++++++++byte[]+buffer+=+new+byte[]+{+1,+0,+2,+3,+4,+5,+6,+7,+8,+9,+9,+10,+1,+2,+3,+4,+5,+6,+7,+8,+9,+10,+11,+5,+5,+0,+5,+5,+1,+2+};
++++++++byte[]+beginPattern+=+new+byte[]+{+1,+0,+2+};
++++++++byte[]+middlePattern+=+new+byte[]+{+8,+9,+10+};
++++++++byte[]+endPattern+=+new+byte[]+{+9,+10,+11+};
++++++++byte[]+wholePattern+=+new+byte[]+{+1,+0,+2,+3,+4,+5,+6,+7,+8,+9,+9,+10,+1,+2,+3,+4,+5,+6,+7,+8,+9,+10,+11+};
++++++++byte[]+noMatchPattern+=+new+byte[]+{+7,+7,+7+};

++++++++int+beginIndex+=+ByteArrayPatternIndex(buffer,+beginPattern);
++++++++int+middleIndex+=+ByteArrayPatternIndex(buffer,+middlePattern);
++++++++int+endIndex+=+ByteArrayPatternIndex(buffer,+endPattern);
++++++++int+wholeIndex+=+ByteArrayPatternIndex(buffer,+wholePattern);
++++++++int+noMatchIndex+=+ByteArrayPatternIndex(buffer,+noMatchPattern);
++++}

++++///+<summary>
++++///+Returns+the+index+of+the+first+occurrence+of+a+byte+array+within+another+byte+array
++++///+</summary>
++++///+<param+name="buffer">The+byte+array+to+be+searched</param>
++++///+<param+name="pattern">The+byte+array+that+contains+the+pattern+to+be+found</param>
++++///+<returns>If+buffer+contains+pattern+then+the+index+of+the+first+occurrence+of+pattern+within+buffer;+otherwise,+-1</returns>
++++public+static+int+ByteArrayPatternIndex(byte[]+buffer,+byte[]+pattern)
++++{
++++++++if+(buffer+!=+null+&&+pattern+!=+null+&&+pattern.Length+<=+buffer.Length)
++++++++{
++++++++++++int+resumeIndex;
++++++++++++for+(int+i+=+0;+i+<=+buffer.Length+-+pattern.Length;+i%2B%2B)
++++++++++++{
++++++++++++++++if+(buffer[i]+==+pattern[0])+//+Current+byte+equals+first+byte+of+pattern
++++++++++++++++{
++++++++++++++++++++resumeIndex+=+0;
++++++++++++++++++++for+(int+x+=+1;+x+<+pattern.Length;+x%2B%2B)
++++++++++++++++++++{
++++++++++++++++++++++++if+(buffer[i+%2B+x]+==+pattern[x])
++++++++++++++++++++++++{
++++++++++++++++++++++++++++if+(x+==+pattern.Length+-+1)++//+Matched+the+entire+pattern
++++++++++++++++++++++++++++++++return+i;
++++++++++++++++++++++++++++else+if+(resumeIndex+==+0+&&+buffer[i+%2B+x]+==+pattern[0])++//+The+current+byte+equals+the+first+byte+of+the+pattern+so+start+here+on+the+next+outer+loop+iteration
++++++++++++++++++++++++++++++++resumeIndex+=+i+%2B+x;
++++++++++++++++++++++++}
++++++++++++++++++++++++else
++++++++++++++++++++++++{
++++++++++++++++++++++++++++if+(resumeIndex+>+0)
++++++++++++++++++++++++++++++++i+=+resumeIndex+-+1;++//+The+outer+loop+iterator+will+increment+so+subtract+one
++++++++++++++++++++++++++++else+if+(x+>+1)
++++++++++++++++++++++++++++++++i+%2B=+(x+-+1);++//+Advance+the+outer+loop+variable+since+we+already+checked+these+bytes
++++++++++++++++++++++++++++break;
++++++++++++++++++++++++}
++++++++++++++++++++}
++++++++++++++++}
++++++++++++}
++++++++}
++++++++return+-1;
++++}

++++///+<summary>
++++///+Returns+the+indexes+of+each+occurrence+of+a+byte+array+within+another+byte+array
++++///+</summary>
++++///+<param+name="buffer">The+byte+array+to+be+searched</param>
++++///+<param+name="pattern">The+byte+array+that+contains+the+pattern+to+be+found</param>
++++///+<returns>If+buffer+contains+pattern+then+the+indexes+of+the+occurrences+of+pattern+within+buffer;+otherwise,+null</returns>
++++///+<remarks>A+single+byte+in+the+buffer+array+can+only+be+part+of+one+match.++For+example,+if+searching+for+1,2,1+in+1,2,1,2,1+only+zero+would+be+returned.</remarks>
++++public+static+int[]+ByteArrayPatternIndex(byte[]+buffer,+byte[]+pattern)
++++{
++++++++if+(buffer+!=+null+&&+pattern+!=+null+&&+pattern.Length+<=+buffer.Length)
++++++++{
++++++++++++List<int>+indexes+=+new+List<int>();
++++++++++++int+resumeIndex;
++++++++++++for+(int+i+=+0;+i+<=+buffer.Length+-+pattern.Length;+i%2B%2B)
++++++++++++{
++++++++++++++++if+(buffer[i]+==+pattern[0])+//+Current+byte+equals+first+byte+of+pattern
++++++++++++++++{
++++++++++++++++++++resumeIndex+=+0;
++++++++++++++++++++for+(int+x+=+1;+x+<+pattern.Length;+x%2B%2B)
++++++++++++++++++++{
++++++++++++++++++++++++if+(buffer[i+%2B+x]+==+pattern[x])
++++++++++++++++++++++++{
++++++++++++++++++++++++++++if+(x+==+pattern.Length+-+1)++//+Matched+the+entire+pattern
++++++++++++++++++++++++++++++++indexes.Add(i);
++++++++++++++++++++++++++++else+if+(resumeIndex+==+0+&&+buffer[i+%2B+x]+==+pattern[0])++//+The+current+byte+equals+the+first+byte+of+the+pattern+so+start+here+on+the+next+outer+loop+iteration
++++++++++++++++++++++++++++++++resumeIndex+=+i+%2B+x;
++++++++++++++++++++++++}
++++++++++++++++++++++++else
++++++++++++++++++++++++{
++++++++++++++++++++++++++++if+(resumeIndex+>+0)
++++++++++++++++++++++++++++++++i+=+resumeIndex+-+1;++//+The+outer+loop+iterator+will+increment+so+subtract+one
++++++++++++++++++++++++++++else+if+(x+>+1)
++++++++++++++++++++++++++++++++i+%2B=+(x+-+1);++//+Advance+the+outer+loop+variable+since+we+already+checked+these+bytes
++++++++++++++++++++++++++++break;
++++++++++++++++++++++++}
++++++++++++++++++++}
++++++++++++++++}
++++++++++++}
++++++++++++if+(indexes.Count+>+0)
++++++++++++++++return+indexes.ToArray();
++++++++}
++++++++return+null;
++++}|code-block|syntax|javascript|1477267|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Just another answer that is easy to follow and pretty efficient for a O(n) type of
operation without using unsafe code or copying parts of the source arrays.

Be sure to test. Some of the suggestions found on this topic are susceptible to gotta situations.

<pre><code> static void Main(string[] args)
 {
 // 1 1 1 1 1 1 1 1 1 1 2 2 2
 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
 byte[] buffer = new byte[] { 1, 0, 2, 3, 4, 5, 6, 7, 8, 9, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 5, 5, 0, 5, 5, 1, 2 };
 byte[] beginPattern = new byte[] { 1, 0, 2 };
 byte[] middlePattern = new byte[] { 8, 9, 10 };
 byte[] endPattern = new byte[] { 9, 10, 11 };
 byte[] wholePattern = new byte[] { 1, 0, 2, 3, 4, 5, 6, 7, 8, 9, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
 byte[] noMatchPattern = new byte[] { 7, 7, 7 };

 int beginIndex = ByteArrayPatternIndex(buffer, beginPattern);
 int middleIndex = ByteArrayPatternIndex(buffer, middlePattern);
 int endIndex = ByteArrayPatternIndex(buffer, endPattern);
 int wholeIndex = ByteArrayPatternIndex(buffer, wholePattern);
 int noMatchIndex = ByteArrayPatternIndex(buffer, noMatchPattern);
 }

 /// &lt;summary&gt;
 /// Returns the index of the first occurrence of a byte array within another byte array
 /// &lt;/summary&gt;
 /// &lt;param name="buffer"&gt;The byte array to be searched&lt;/param&gt;
 /// &lt;param name="pattern"&gt;The byte array that contains the pattern to be found&lt;/param&gt;
 /// &lt;returns&gt;If buffer contains pattern then the index of the first occurrence of pattern within buffer; otherwise, -1&lt;/returns&gt;
 public static int ByteArrayPatternIndex(byte[] buffer, byte[] pattern)
 {
 if (buffer != null &amp;&amp; pattern != null &amp;&amp; pattern.Length &lt;= buffer.Length)
 {
 int resumeIndex;
 for (int i = 0; i &lt;= buffer.Length - pattern.Length; i++)
 {
 if (buffer[i] == pattern[0]) // Current byte equals first byte of pattern
 {
 resumeIndex = 0;
 for (int x = 1; x &lt; pattern.Length; x++)
 {
 if (buffer[i + x] == pattern[x])
 {
 if (x == pattern.Length - 1) // Matched the entire pattern
 return i;
 else if (resumeIndex == 0 &amp;&amp; buffer[i + x] == pattern[0]) // The current byte equals the first byte of the pattern so start here on the next outer loop iteration
 resumeIndex = i + x;
 }
 else
 {
 if (resumeIndex &gt; 0)
 i = resumeIndex - 1; // The outer loop iterator will increment so subtract one
 else if (x &gt; 1)
 i += (x - 1); // Advance the outer loop variable since we already checked these bytes
 break;
 }
 }
 }
 }
 }
 return -1;
 }

 /// &lt;summary&gt;
 /// Returns the indexes of each occurrence of a byte array within another byte array
 /// &lt;/summary&gt;
 /// &lt;param name="buffer"&gt;The byte array to be searched&lt;/param&gt;
 /// &lt;param name="pattern"&gt;The byte array that contains the pattern to be found&lt;/param&gt;
 /// &lt;returns&gt;If buffer contains pattern then the indexes of the occurrences of pattern within buffer; otherwise, null&lt;/returns&gt;
 /// &lt;remarks&gt;A single byte in the buffer array can only be part of one match. For example, if searching for 1,2,1 in 1,2,1,2,1 only zero would be returned.&lt;/remarks&gt;
 public static int[] ByteArrayPatternIndex(byte[] buffer, byte[] pattern)
 {
 if (buffer != null &amp;&amp; pattern != null &amp;&amp; pattern.Length &lt;= buffer.Length)
 {
 List&lt;int&gt; indexes = new List&lt;int&gt;();
 int resumeIndex;
 for (int i = 0; i &lt;= buffer.Length - pattern.Length; i++)
 {
 if (buffer[i] == pattern[0]) // Current byte equals first byte of pattern
 {
 resumeIndex = 0;
 for (int x = 1; x &lt; pattern.Length; x++)
 {
 if (buffer[i + x] == pattern[x])
 {
 if (x == pattern.Length - 1) // Matched the entire pattern
 indexes.Add(i);
 else if (resumeIndex == 0 &amp;&amp; buffer[i + x] == pattern[0]) // The current byte equals the first byte of the pattern so start here on the next outer loop iteration
 resumeIndex = i + x;
 }
 else
 {
 if (resumeIndex &gt; 0)
 i = resumeIndex - 1; // The outer loop iterator will increment so subtract one
 else if (x &gt; 1)
 i += (x - 1); // Advance the outer loop variable since we already checked these bytes
 break;
 }
 }
 }
 }
 if (indexes.Count &gt; 0)
 return indexes.ToArray();
 }
 return null;
 }
</code></pre>

blocks|key|1692446|text|我对上面福巴尔答案的版本，它避免了搜索超过干草堆的尽头，并允许指定起始偏移量。假设针不是空的或不比干草堆长。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1692447|public+static+unsafe+long+IndexOf(this+byte[]+haystack,+byte[]+needle,+long+startOffset+=+0)
{+
++++fixed+(byte*+h+=+haystack)+fixed+(byte*+n+=+needle)
++++{
++++++++for+(byte*+hNext+=+h+%2B+startOffset,+hEnd+=+h+%2B+haystack.LongLength+%2B+1+-+needle.LongLength,+nEnd+=+n+%2B+needle.LongLength;+hNext+<+hEnd;+hNext%2B%2B)
++++++++++++for+(byte*+hInc+=+hNext,+nInc+=+n;+*nInc+==+*hInc;+hInc%2B%2B)
++++++++++++++++if+(%2B%2BnInc+==+nEnd)
++++++++++++++++++++return+hNext+-+h;
++++++++return+-1;
++++}
}|code-block|syntax|javascript|1692448|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

My version of Foubar's answer above, which avoids searching past the end of the haystack, and allows specifying a starting offset. Assumes needle is not empty or longer than the haystack. 

<pre><code>public static unsafe long IndexOf(this byte[] haystack, byte[] needle, long startOffset = 0)
{ 
 fixed (byte* h = haystack) fixed (byte* n = needle)
 {
 for (byte* hNext = h + startOffset, hEnd = h + haystack.LongLength + 1 - needle.LongLength, nEnd = n + needle.LongLength; hNext &lt; hEnd; hNext++)
 for (byte* hInc = hNext, nInc = n; *nInc == *hInc; hInc++)
 if (++nInc == nEnd)
 return hNext - h;
 return -1;
 }
}
</code></pre>

blocks|key|1477383|text|您可以使用ORegex：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1477384|var+oregex+=+new+ORegex<byte>("{0}{1}{2}",+x=>+x==12,+x=>+x==3,+x=>+x==5);
var+toSearch+=+new+byte[]{1,1,12,3,5,1,12,3,5,5,5,5};

var+found+=+oregex.Matches(toSearch);|code-block|syntax|javascript|1477385|将找到两个匹配项：|1477386|i:2;l:3
i:6;l:3|1477387|复杂度:+O(n*m)在最坏的情况下，由于内部状态机，在现实生活中它是O(n)。在某些情况下，它比.NET正则表达式更快。它结构紧凑，速度快，是专门为阵列方向图匹配而设计的。|1477388|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You can use ORegex:

<pre><code>var oregex = new ORegex&lt;byte&gt;("{0}{1}{2}", x=&gt; x==12, x=&gt; x==3, x=&gt; x==5);
var toSearch = new byte[]{1,1,12,3,5,1,12,3,5,5,5,5};

var found = oregex.Matches(toSearch);
</code></pre>

Will be found two matches:

<pre><code>i:2;l:3
i:6;l:3
</code></pre>

Complexity: O(n*m) in worst case, in real life it is O(n) because of internal state machine. It is faster than .NET Regex in some cases. It is compact, fast and designed especialy for array pattern matching.

blocks|key|1692627|text|这是我的建议，更简单，更快：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1692628|int+Search(byte[]+src,+byte[]+pattern)
{
++++int+maxFirstCharSlot+=+src.Length+-+pattern.Length+%2B+1;
++++for+(int+i+=+0;+i+<+maxFirstCharSlot;+i%2B%2B)
++++{
++++++++if+(src[i]+!=+pattern[0])+//+compare+only+first+byte
++++++++++++continue;
++++++++
++++++++//+found+a+match+on+first+byte,+now+try+to+match+rest+of+the+pattern
++++++++for+(int+j+=+pattern.Length+-+1;+j+>=+1;+j--)+
++++++++{
+++++++++++if+(src[i+%2B+j]+!=+pattern[j])+break;
+++++++++++if+(j+==+1)+return+i;
++++++++}
++++}
++++return+-1;
}|code-block|syntax|javascript|1692629|这段代码背后的逻辑是这样的:首先它只搜索第一个字节(这是关键改进)，当找到第一个字节时，我尝试匹配模式的其余部分|1692630|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

This is my propossal, more simple and faster:
<pre><code>int Search(byte[] src, byte[] pattern)
{
 int maxFirstCharSlot = src.Length - pattern.Length + 1;
 for (int i = 0; i &lt; maxFirstCharSlot; i++)
 {
 if (src[i] != pattern[0]) // compare only first byte
 continue;
 
 // found a match on first byte, now try to match rest of the pattern
 for (int j = pattern.Length - 1; j &gt;= 1; j--) 
 {
 if (src[i + j] != pattern[j]) break;
 if (j == 1) return i;
 }
 }
 return -1;
}
</code></pre>
The logic behind this code is this: in first place it search ONLY THE FIRST BYTE (this is the key improvement) and when is found this first byte, i try to match the rest of pattern

blocks|key|1477482|text|我试图理解桑切斯的建议，并使search.Below代码的性能更快，equal.But代码更容易理解。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1477483|public+int+Search3(byte[]+src,+byte[]+pattern)
++++{
++++++++int+index+=+-1;

++++++++for+(int+i+=+0;+i+<+src.Length;+i%2B%2B)
++++++++{
++++++++++++if+(src[i]+!=+pattern[0])
++++++++++++{
++++++++++++++++continue;
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++bool+isContinoue+=+true;
++++++++++++++++for+(int+j+=+1;+j+<+pattern.Length;+j%2B%2B)
++++++++++++++++{
++++++++++++++++++++if+(src[%2B%2Bi]+!=+pattern[j])
++++++++++++++++++++{
++++++++++++++++++++++++isContinoue+=+true;
++++++++++++++++++++++++break;
++++++++++++++++++++}
++++++++++++++++++++if(j+==+pattern.Length+-+1)
++++++++++++++++++++{
++++++++++++++++++++++++isContinoue+=+false;
++++++++++++++++++++}
++++++++++++++++}
++++++++++++++++if+(+!+isContinoue)
++++++++++++++++{
++++++++++++++++++++index+=+i-(+pattern.Length-1)+;
++++++++++++++++++++break;
++++++++++++++++}
++++++++++++}
++++++++}
++++++++return+index;
++++}|code-block|syntax|javascript|1477484|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I tried to understand Sanchez's proposal and make faster search.Below code's performance nearly equal.But code is more understandable.

<pre><code>public int Search3(byte[] src, byte[] pattern)
 {
 int index = -1;

 for (int i = 0; i &lt; src.Length; i++)
 {
 if (src[i] != pattern[0])
 {
 continue;
 }
 else
 {
 bool isContinoue = true;
 for (int j = 1; j &lt; pattern.Length; j++)
 {
 if (src[++i] != pattern[j])
 {
 isContinoue = true;
 break;
 }
 if(j == pattern.Length - 1)
 {
 isContinoue = false;
 }
 }
 if ( ! isContinoue)
 {
 index = i-( pattern.Length-1) ;
 break;
 }
 }
 }
 return index;
 }
</code></pre>

blocks|key|1692719|text|这是我自己在这个主题上的方法。我使用指针来确保它在较大的数组上更快。此函数将返回序列的第一个匹配项(这就是我在本例中需要的)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1692720|我相信您可以稍微修改它，以便返回一个包含所有事件的列表。|1692721|我做的事情相当简单。我遍历源数组(haystack)，直到找到模式的第一个字节(针)。当找到第一个字节时，我继续单独检查下一个字节是否与模式的下一个字节匹配。如果没有，在尝试匹配指针之前，我会像往常一样从索引(在干草堆中)继续搜索。|1692722|下面是代码：|1692723|++++public+unsafe+int+IndexOfPattern(byte[]+src,+byte[]+pattern)
++++{
++++++++fixed(byte+*srcPtr+=+&src[0])
++++++++fixed+(byte*+patternPtr+=+&pattern[0])
++++++++{
++++++++++++for+(int+x+=+0;+x+<+src.Length;+x%2B%2B)
++++++++++++{
++++++++++++++++byte+currentValue+=+*(srcPtr+%2B+x);

++++++++++++++++if+(currentValue+!=+*patternPtr)+continue;

++++++++++++++++bool+match+=+false;

++++++++++++++++for+(int+y+=+0;+y+<+pattern.Length;+y%2B%2B)
++++++++++++++++{
++++++++++++++++++++byte+tempValue+=+*(srcPtr+%2B+x+%2B+y);
++++++++++++++++++++if+(tempValue+!=+*(patternPtr+%2B+y))
++++++++++++++++++++{
++++++++++++++++++++++++match+=+false;
++++++++++++++++++++++++break;
++++++++++++++++++++}

++++++++++++++++++++match+=+true;
++++++++++++++++}

++++++++++++++++if+(match)
++++++++++++++++++++return+x;
++++++++++++}
++++++++}
++++++++return+-1;
++++}|code-block|syntax|javascript|1692724|安全代码如下：|1692725|++++public+int+IndexOfPatternSafe(byte[]+src,+byte[]+pattern)
++++{
++++++++for+(int+x+=+0;+x+<+src.Length;+x%2B%2B)
++++++++{
++++++++++++byte+currentValue+=+src[x];
++++++++++++if+(currentValue+!=+pattern[0])+continue;

++++++++++++bool+match+=+false;

++++++++++++for+(int+y+=+0;+y+<+pattern.Length;+y%2B%2B)
++++++++++++{
++++++++++++++++byte+tempValue+=+src[x+%2B+y];
++++++++++++++++if+(tempValue+!=+pattern[y])
++++++++++++++++{
++++++++++++++++++++match+=+false;
++++++++++++++++++++break;
++++++++++++++++}

++++++++++++++++match+=+true;
++++++++++++}

++++++++++++if+(match)
++++++++++++++++return+x;
++++++++}

++++++++return+-1;
++++}|1692726|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|V|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

This is my own approach on the topic. I used pointers to ensure that it is faster on larger arrays. This function will return the first occurence of the sequence (which is what I needed in my own case). 

I am sure you can modify it a little bit in order to return a list with all occurences.

What I do is fairly simple. I loop through the source array (haystack) until I find the first byte of the pattern (needle). When the first byte is found, I continue checking separately if the next bytes match the next bytes of the pattern. If not, I continue searching as normal, from the index (in the haystack) I was previously on, before trying to match the needle.

So here's the code:

<pre><code> public unsafe int IndexOfPattern(byte[] src, byte[] pattern)
 {
 fixed(byte *srcPtr = &amp;src[0])
 fixed (byte* patternPtr = &amp;pattern[0])
 {
 for (int x = 0; x &lt; src.Length; x++)
 {
 byte currentValue = *(srcPtr + x);

 if (currentValue != *patternPtr) continue;

 bool match = false;

 for (int y = 0; y &lt; pattern.Length; y++)
 {
 byte tempValue = *(srcPtr + x + y);
 if (tempValue != *(patternPtr + y))
 {
 match = false;
 break;
 }

 match = true;
 }

 if (match)
 return x;
 }
 }
 return -1;
 }
</code></pre>

Safe code below:

<pre><code> public int IndexOfPatternSafe(byte[] src, byte[] pattern)
 {
 for (int x = 0; x &lt; src.Length; x++)
 {
 byte currentValue = src[x];
 if (currentValue != pattern[0]) continue;

 bool match = false;

 for (int y = 0; y &lt; pattern.Length; y++)
 {
 byte tempValue = src[x + y];
 if (tempValue != pattern[y])
 {
 match = false;
 break;
 }

 match = true;
 }

 if (match)
 return x;
 }

 return -1;
 }
</code></pre>

blocks|key|1692775|text|前几天我遇到了这个问题，试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1692776|++++++++public+static+long+FindBinaryPattern(byte[]+data,+byte[]+pattern)
++++++++{
++++++++++++using+(MemoryStream+stream+=+new+MemoryStream(data))
++++++++++++{
++++++++++++++++return+FindBinaryPattern(stream,+pattern);
++++++++++++}
++++++++}
++++++++public+static+long+FindBinaryPattern(string+filename,+byte[]+pattern)
++++++++{
++++++++++++using+(FileStream+stream+=+new+FileStream(filename,+FileMode.Open))
++++++++++++{
++++++++++++++++return+FindBinaryPattern(stream,+pattern);
++++++++++++}
++++++++}
++++++++public+static+long+FindBinaryPattern(Stream+stream,+byte[]+pattern)
++++++++{
++++++++++++byte[]+buffer+=+new+byte[1024+*+1024];
++++++++++++int+patternIndex+=+0;
++++++++++++int+read;
++++++++++++while+((read+=+stream.Read(buffer,+0,+buffer.Length))+>+0)
++++++++++++{
++++++++++++++++for+(int+bufferIndex+=+0;+bufferIndex+<+read;+%2B%2BbufferIndex)
++++++++++++++++{
++++++++++++++++++++if+(buffer[bufferIndex]+==+pattern[patternIndex])
++++++++++++++++++++{
++++++++++++++++++++++++%2B%2BpatternIndex;
++++++++++++++++++++++++if+(patternIndex+==+pattern.Length)
++++++++++++++++++++++++++++return+stream.Position+-+(read+-+bufferIndex)+-+pattern.Length+%2B+1;
++++++++++++++++++++}
++++++++++++++++++++else
++++++++++++++++++++{
++++++++++++++++++++++++patternIndex+=+0;
++++++++++++++++++++}
++++++++++++++++}
++++++++++++}
++++++++++++return+-1;
++++++++}|code-block|syntax|javascript|1692777|它没有做任何聪明的事情，只是让它保持简单。|1692778|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I hit this problem the other day, try this:

<pre><code> public static long FindBinaryPattern(byte[] data, byte[] pattern)
 {
 using (MemoryStream stream = new MemoryStream(data))
 {
 return FindBinaryPattern(stream, pattern);
 }
 }
 public static long FindBinaryPattern(string filename, byte[] pattern)
 {
 using (FileStream stream = new FileStream(filename, FileMode.Open))
 {
 return FindBinaryPattern(stream, pattern);
 }
 }
 public static long FindBinaryPattern(Stream stream, byte[] pattern)
 {
 byte[] buffer = new byte[1024 * 1024];
 int patternIndex = 0;
 int read;
 while ((read = stream.Read(buffer, 0, buffer.Length)) &gt; 0)
 {
 for (int bufferIndex = 0; bufferIndex &lt; read; ++bufferIndex)
 {
 if (buffer[bufferIndex] == pattern[patternIndex])
 {
 ++patternIndex;
 if (patternIndex == pattern.Length)
 return stream.Position - (read - bufferIndex) - pattern.Length + 1;
 }
 else
 {
 patternIndex = 0;
 }
 }
 }
 return -1;
 }
</code></pre>

It does nothing clever, keeps it simple.

blocks|key|1692875|text|如果您使用的是.NET核心2.1或更高版本(或.NET标准2.1或更高版本的平台)，则可以将MemoryExtensions.IndexOf扩展方法与new+Span+type配合使用|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1692876|int+matchIndex+=+toBeSearched.AsSpan().IndexOf(pattern);|code-block|syntax|javascript|1692877|要查找所有匹配项，可以使用如下命令：|1692878|public+static+IEnumerable<int>+IndexesOf(this+byte[]+haystack,+byte[]+needle,
++++int+startIndex+=+0,+bool+includeOverlapping+=+false)
{
++++int+matchIndex+=+haystack.AsSpan(startIndex).IndexOf(needle);
++++while+(matchIndex+>=+0)
++++{
++++++++yield+return+startIndex+%2B+matchIndex;
++++++++startIndex+%2B=+matchIndex+%2B+(includeOverlapping+?+1+:+needle.Length);
++++++++matchIndex+=+haystack.AsSpan(startIndex).IndexOf(needle);
++++}
}|1692879|不幸的是，implementation+in+.NET+Core+2.1+-+3.0使用了一种迭代的“在第一字节上优化单字节搜索，然后检查余数”的方法，而不是fast+string+search+algorithm，但这种情况可能会在未来的版本中发生变化。|1692880|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.microsoft.com/en-us/dotnet/api/system.memoryextensions.indexof?view=netcore-3.0|1|https://github.com/dotnet/corefxlab/blob/master/docs/specs/span.md|2|https://github.com/dotnet/corefx/blob/v3.0.0/src/Common/src/CoreLib/System/SpanHelpers.Byte.cs#L23|3|https://stackoverflow.com/q/3183582^0|1A|O|27|4|1A|O|0|23|D|1|0|0|0|0|5|11|2|27|S|3|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@$9|19|A|1A|1|1B]|$9|1C|A|1D|1|1E]]|E|$]]|$1|F|3|G|5|H|7|1F|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1G|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1H|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1I|8|@]|D|@$9|1J|A|1K|1|1L]|$9|1M|A|1N|1|1O]]|E|$]]|$1|Q|3|-4|5|6|7|1P|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]|Y|$5|T|U|V|E|$W|Z]]|10|$5|T|U|V|E|$W|11]]|12|$5|T|U|V|E|$W|13]]]]

If you are using .NET Core 2.1 or later (or a .NET Standard 2.1 or later platform) you can use the <a href="https://docs.microsoft.com/en-us/dotnet/api/system.memoryextensions.indexof?view=netcore-3.0" rel="nofollow noreferrer"><code>MemoryExtensions.IndexOf</code></a> extension method with the <a href="https://github.com/dotnet/corefxlab/blob/master/docs/specs/span.md" rel="nofollow noreferrer">new <code>Span</code> type</a>:

<pre class="lang-csharp prettyprint-override"><code>int matchIndex = toBeSearched.AsSpan().IndexOf(pattern);
</code></pre>

To find all occurrences, you could use something like:

<pre class="lang-csharp prettyprint-override"><code>public static IEnumerable&lt;int&gt; IndexesOf(this byte[] haystack, byte[] needle,
 int startIndex = 0, bool includeOverlapping = false)
{
 int matchIndex = haystack.AsSpan(startIndex).IndexOf(needle);
 while (matchIndex &gt;= 0)
 {
 yield return startIndex + matchIndex;
 startIndex += matchIndex + (includeOverlapping ? 1 : needle.Length);
 matchIndex = haystack.AsSpan(startIndex).IndexOf(needle);
 }
}
</code></pre>

Unfortunately, the <a href="https://github.com/dotnet/corefx/blob/v3.0.0/src/Common/src/CoreLib/System/SpanHelpers.Byte.cs#L23" rel="nofollow noreferrer">implementation in .NET Core 2.1 - 3.0</a> uses an iterated "optimized single-byte search on first-byte then check remainder" approach rather than a <a href="https://stackoverflow.com/q/3183582">fast string search algorithm</a>, but that could change in a future release.

blocks|key|1692985|text|我使用一个简单的泛型方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1692986|void+Main()
{
++++Console.WriteLine(new[]{255,1,3,4,8,99,92,9,0,5,128}.Position(new[]{9,0}));
++++
++++Console.WriteLine("Philipp".ToArray().Position("il".ToArray()));

++++Console.WriteLine(new[]+{+"Mo",+"Di",+"Mi",+"Do",+"Fr",+"Sa",+"So","Mo",+"Di",+"Mi",+"Do",+"Fr",+"Sa",+"So"}.Position(new[]+{+"Fr",+"Sa"+},+7));
}

static+class+Extensions
{
++++public+static+int+Position<T>(this+T[]+source,+T[]+pattern,+int+start+=+0)
++++{
++++++++var+matchLenght+=+0;
++++++++foreach+(var+indexSource+in+Enumerable.Range(start,+source.Length+-+pattern.Length))
++++++++++++foreach+(var+indexPattern+in+Enumerable.Range(0,+pattern.Length))
++++++++++++++++if+(source[indexSource+%2B+indexPattern].Equals(pattern[indexPattern]))
++++++++++++++++++++if+(%2B%2BmatchLenght+==+pattern.Length)
++++++++++++++++++++++++return+indexSource;
++++++++return+-1;
++++}
}|code-block|syntax|javascript|1692987|输出：|1692988|7
2
11|1692989|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I use a simple generic method
<pre><code>void Main()
{
 Console.WriteLine(new[]{255,1,3,4,8,99,92,9,0,5,128}.Position(new[]{9,0}));
 
 Console.WriteLine(&quot;Philipp&quot;.ToArray().Position(&quot;il&quot;.ToArray()));

 Console.WriteLine(new[] { &quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;,&quot;Mo&quot;, &quot;Di&quot;, &quot;Mi&quot;, &quot;Do&quot;, &quot;Fr&quot;, &quot;Sa&quot;, &quot;So&quot;}.Position(new[] { &quot;Fr&quot;, &quot;Sa&quot; }, 7));
}

static class Extensions
{
 public static int Position&lt;T&gt;(this T[] source, T[] pattern, int start = 0)
 {
 var matchLenght = 0;
 foreach (var indexSource in Enumerable.Range(start, source.Length - pattern.Length))
 foreach (var indexPattern in Enumerable.Range(0, pattern.Length))
 if (source[indexSource + indexPattern].Equals(pattern[indexPattern]))
 if (++matchLenght == pattern.Length)
 return indexSource;
 return -1;
 }
}
</code></pre>
Output:
<pre><code>7
2
11
</code></pre>

Anyone know a good and effective way to search/match for a byte pattern in an byte[] array and then return the positions.

For example

<pre><code>byte[] pattern = new byte[] {12,3,5,76,8,0,6,125};

byte[] toBeSearched = new byte[] {23,36,43,76,125,56,34,234,12,3,5,76,8,0,6,125,234,56,211,122,22,4,7,89,76,64,12,3,5,76,8,0,6,125}
</code></pre>

byte[] array pattern search

任何人都知道在byte[]数组中搜索/匹配字节模式，然后返回位置的有效方法。例如byte[] pattern = new byte[] {12,3,5,76,8,0,6,125};byte[] toBeSearched = new byte[] {23,36,43,76,125,56,34,234,12,3,5,76,...

问byte[]数组模式搜索
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问byte[]数组模式搜索EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问byte[]数组模式搜索
EN