Question

我有以下代码：

var file = //Memory stream with a file in it
var bytes = file.ToArray();

我需要在bytes中搜索指定字节序列的第一次出现（如果有）：0xff，0xd8。（目的是找到嵌入文件中的图像）

因此，如果例如bytes[6501]包含0xff而bytes[6502]包含0xd8，那就是匹配，我需要返回的位置索引（6501），或者new array，它是bytes数组的副本，但它没有旧数组6501以下的键。

我目前的解决方案是循环：

 for (var index = 0; index < bytes.Length; index++)
 {
     if((new byte[] {0xff, 0xd8}).SequenceEqual(bytes.Skip(index).Take(2))
    ...

但是当它处理更大的文件时它很慢。

有没有更有效的方法来处理这个？

Answer 1

如果这是时间关键代码，我发现C＃编译器（Mono的实现和Microsoft）都有特殊的逻辑来优化简单的扫描循环。

因此，从分析经验来看，我使用硬编码的第一元素搜索实现序列搜索，如下所示：

/// <summary>Looks for the next occurrence of a sequence in a byte array</summary>
/// <param name="array">Array that will be scanned</param>
/// <param name="start">Index in the array at which scanning will begin</param>
/// <param name="sequence">Sequence the array will be scanned for</param>
/// <returns>
///   The index of the next occurrence of the sequence of -1 if not found
/// </returns>
private static int findSequence(byte[] array, int start, byte[] sequence) {
  int end = array.Length - sequence.Length; // past here no match is possible
  byte firstByte = sequence[0]; // cached to tell compiler there's no aliasing

  while (start < end) {
    // scan for first byte only. compiler-friendly.
    if (array[start] == firstByte) {
      // scan for rest of sequence
      for (int offset = 1; offset < sequence.Length; ++offset) {
        if (array[start + offset] != sequence[offset]) {
          break; // mismatch? continue scanning with next byte
        } else if (offset == sequence.Length - 1) {
          return start; // all bytes matched!
        }
      }
    }
    ++start;
  }

  // end of array reached without match
  return -1;
}

比其他建议要长一点，并且容易出现一分之一的错误，但如果您正在扫描大量数据或为频繁的设备IO执行此操作，则此设置将避免为垃圾收集器提供服务非常好地优化。

Answer 2

public int FindSequence(byte[] source, byte[] seq)
{
    var start = -1;
    for (var i = 0; i < source.Length - seq.Length + 1 && start == -1; i++)
    {
        var j = 0;
        for (; j < seq.Length && source[i+j] == seq[j]; j++) {}
        if (j == seq.Length) start = i;
    }
    return start;
}

Answer 3

简单怎么样？？

bytes[] pattern = new bytes[] { 1, 2, 3, 4, 5 };
for (var index = 0, end = bytes.Length - pattern.length; index < end; index++)
{
    bool found = false;
    for(int j = 0; j < pattern.Length && !found; j++)
    {
        found = bytes[index + j] == pattern[j];
    }
    if(found)
        return index;
}

请注意我没有在c＃中编码一段时间，所以请原谅语法错误（如果有的话）。将此视为伪代码（不再引发索引错误）：）

Answer 4

您希望使用for循环检查数组。你的代码很慢的原因很简单。

反编译说明原因：

public static IEnumerable<TSource> Skip<TSource>(this IEnumerable<TSource> source, int count)
{
  if (source == null)
    throw Error.ArgumentNull("source");
  else
    return Enumerable.SkipIterator<TSource>(source, count);
}

private static IEnumerable<TSource> SkipIterator<TSource>(IEnumerable<TSource> source, int count)
{
  using (IEnumerator<TSource> enumerator = source.GetEnumerator())
  {
    while (count > 0 && enumerator.MoveNext())
      --count;
    if (count <= 0)
    {
      while (enumerator.MoveNext())
        yield return enumerator.Current;
    }
  }
}

对于每个你正在循环的你正在执行跳过，基本上不必要地再次迭代你的数组。

有些Linq操作包含在可能的情况下使用索引器的优化 - 不幸的是，skip不是其中之一。

PS：

如果我是你，我会将你的代码更改为

var search = new byte[] {0xff, 0xd8};
var current = new byte[2];
var maxSearchRange = bytes.Length -1;
for (var index = 0; index < maxSearchRange; index++)
{
   current[0] = bytes[index];
   current[1] = bytes[index+1];

   if((search).SequenceEqual(current))
       ...

Answer 5

简单的线性搜索是否有缺点？
如果找到则返回起始索引，否则返回-1

private const byte First = 0x0ff;
private const byte Second = 0x0d8;

private static int FindImageStart(IList<byte> bytes) {
    for (var index = 0; index < bytes.Count - 1; index++) {
        if (bytes[index] == First && bytes[index + 1] == Second) {
            return index;
        }
    }
    return -1;
}

在字节数组中查找模式的最有效方法

5 个答案: