如何判断一个Byte数组中是否存在某些连续的数据

Question

例如我要判断如下的数组中是否存在0X68, 0X73, 0X5f, 0X62, 0X61, 0X79这些数据，如果存在，则把第一个元素的下标找出来
byte[] mBTCmdDataBase = { 
     0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X06, 0X00, 0X00, 0X00, 0X06, 0X68, 0X73, 0X5f, 0X62, 0X61, 0X79, 0X00, 0X00, 0X00, 0X00, 0X00, 0X07, 0X00, 0X00, 0X00, 0X20, 0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X01, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X08
         };

Answer 1

最笨的方法就是FOR循环遍历了，应该有比较优的算法查找，关注

Answer 2

怎么感觉想 内存修改...找INT32 INT64 和STRING 我去试下

Answer 3

楼主说的是存在连续串0X68, 0X73, 0X5f, 0X62, 0X61, 0X79
还是存在某一个即可？

Answer 4

byte[] mBTCmdDataBase = { 
     0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X06, 0X00, 0X00, 0X00, 0X06, 0X68, 0X73, 0X5f, 0X62, 0X61, 0X79, 0X00, 0X00, 0X00, 0X00, 0X00, 0X07, 0X00, 0X00, 0X00, 0X20, 0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X01, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X08
         };
byte[] _Value ={ 0X00, 0X00, 0X08 };
MessageBox.Show(GetValueIndex(mBTCmdDataBase, _Value).ToString());
        public int GetValueIndex(byte[] p_Data, byte[] p_Value)
        {
            bool _ValueIsData = false;
            for (int i = 0; i != p_Data.Length; i++)
            {
                _ValueIsData = true;
                for (int z = 0; z != p_Value.Length; z++)
                {
                    if (p_Value[z] != p_Data[i + z])
                    {
                        _ValueIsData = false;
                        break;
                    }
                }
                if (_ValueIsData) return i;               
            }
            return -1;
        }

Answer 5

using System;class Program
{
  static void Main()
  {
    byte[] mBTCmdDataBase =
    { 
      0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 
      0X04, 0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 
      0X00, 0X04, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X00, 0X00, 
      0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X06, 
      0X00, 0X00, 0X00, 0X06, 0X68, 0X73, 0X5f, 0X62, 0X61, 0X79, 0X00, 
      0X00, 0X00, 0X00, 0X00, 0X07, 0X00, 0X00, 0X00, 0X20, 0X00, 0X00, 
      0X00, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X01, 0X00, 
      0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X08
    };
    byte[] pattern = { 0X68, 0X73, 0X5f, 0X62, 0X61, 0X79 };
    
    string s1 = BitConverter.ToString(mBTCmdDataBase);
    string s2 = BitConverter.ToString(pattern);
    int index = s1.IndexOf(s2);
    if (index >= 0)
    {
      Console.WriteLine("在{0}处找到（索引为0起始）!", index/3);
    }
    else
    {
      Console.WriteLine("没找到！");
    }
  }
}

Answer 6

            byte[] mBTCmdDataBase = { 
                0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X04,
                0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 
                0X00, 0X04, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X00, 
                0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 
                0X00, 0X06, 0X00, 0X00, 0X00, 0X06, 0X68, 0X73, 0X5f, 0X62, 
                0X61, 0X79, 0X00, 0X00, 0X00, 0X00, 0X00, 0X07, 0X00, 0X00,
                0X00, 0X20, 0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X00,
                0X00, 0X00, 0X00, 0X01, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00,
                0X00, 0X08, 0X00, 0X00, 0X00, 0X08         };            bool flag = false; //表示是否找到
            for (int i = 0; i < mBTCmdDataBase.Length; i++)
            {
                //这里是你想要找的0X68 其他值类似
                if (mBTCmdDataBase[i].Equals(0X68) & !flag)
                {
                    flag = true;
                    MessageBox.Show(i.ToString());
                }
            }

Answer 7

目前猜测楼主要的是一个较快的模式匹配算法
若是，则可以考虑BM算法
参考偶朋友写的一个实现
char *qsearch(const char *text, int n, const char *patt, int m)
{
// get the length of the text and the pattern, if necessary
if (n < 0)
n = strlen(text);
if (m < 0)
m = strlen(patt);
if (m == 0)
return (char*)text;// construct delta shift table
int td[128];
for (int c = 0; c < 128; c++)
td[c] = m + 1;
const char* p;
for (p=patt; *p; p++)
td[*p] = m - (p - patt);// start searching...
const char *t, *tx = text;// the main searching loop
while (tx + m <= text + n) {
for (p = patt, t = tx; *p; ++p, ++t) {
if (*p != *t) // found a mismatch
break;
}
if (*p == 0) // Yes! we found it!
return (char*)tx;
tx += td[tx[m]]; // move the pattern by a distance
}
return NULL;
}

Answer 8

8楼的方法好~~直接转换STRING 然后IndexOf

Answer 9

这样也行：using System;
using System.Text;class Program
{
  static void Main()
  {
    byte[] mBTCmdDataBase =
    { 
      0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 
      0X04, 0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 
      0X00, 0X04, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X00, 0X00, 
      0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X06, 
      0X00, 0X00, 0X00, 0X06, 0X68, 0X73, 0X5f, 0X62, 0X61, 0X79, 0X00, 
      0X00, 0X00, 0X00, 0X00, 0X07, 0X00, 0X00, 0X00, 0X20, 0X00, 0X00, 
      0X00, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X01, 0X00, 
      0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X08
    };
    byte[] pattern = { 0X68, 0X73, 0X5f, 0X62, 0X61, 0X79 };
    
    string s1 = new string(Encoding.UTF8.GetChars(mBTCmdDataBase));
    string s2 = new string(Encoding.UTF8.GetChars(pattern));
    int index = s1.IndexOf(s2);
    if (index >= 0)
    {
      Console.WriteLine("在{0}处找到（索引为0起始）!", index);
    }
    else
    {
      Console.WriteLine("没找到！");
    }
  }
}

Answer 10

这个方案针对纯粹的ASCII码是没有什么问题的，但是万一当中给了一些特殊字符有可能会导致string被截断等问题，或者Index不准，例如有UNICODE的情况，感觉有点不妥

Answer 11

我希望能够限定在C#，并且是非UNSafe的代码之下，能否帮我改造改造？

Answer 12

前提是：你的数据类型是 byte[]，8楼和13楼的程序就不会有任何问题。

Answer 13

8楼的程序没有问题。但是13楼的程序有问题，反例如下：using System;
using System.Text;class Program
{
  static void Main()
  {
    byte[] mBTCmdDataBase = { 0Xe5, 0X9b, 0Xbd, 0X68, 0X73, 0X5f, 0X62, 0X61, 0X79 };
    byte[] pattern = { 0X68, 0X73, 0X5f, 0X62, 0X61, 0X79  };
    
    string s1 = new string(Encoding.UTF8.GetChars(mBTCmdDataBase));
    string s2 = new string(Encoding.UTF8.GetChars(pattern));
    int index = s1.IndexOf(s2);
    if (index >= 0)
    {
      Console.WriteLine("在{0}处找到（索引为0起始）!", index);
    }
    else
    {
      Console.WriteLine("没找到！");
    }
  }
}程序的输出为：在1处找到（索引为0起始）!
正确的答案为：在3处找到（索引为0起始）!这是由于一个UTF8字符可能不止占一个byte的缘故。

Answer 14

try this:public class BMS {
        public BMS(string pattern) {
            if (string.IsNullOrEmpty(pattern)) {
                throw new ArgumentException("Must be non null or empty.", "pattern");
            }
            _pattern = pattern;            // init the delta shift table
            int n;
            delta = new int[DELTA_SIZE];
            for (n = 0; n < DELTA_SIZE; ++n) {
                delta[n] = _pattern.Length;
            }
            for (n = 1; n < _pattern.Length; ++n) {
                delta[(int) _pattern[n - 1]] = _pattern.Length - n;
            }
            delta[(int) _pattern[_pattern.Length - 1]] = 1;
        }        public int find(string sourceStr) {
            if (string.IsNullOrEmpty(sourceStr)) {
                throw new ArgumentException("Must be non null or empty.", "sourceStr");
            }
           
            int start = 0;
            int t = start + _pattern.Length;
            while (t <= sourceStr.Length) {
                int p = _pattern.Length;
                while (_pattern[p - 1] == sourceStr[t - 1]) {
                    if (p > 1) {
                        --p;
                        --t;
                    } else {
                        return t - 1;
                    }
                }
                t += delta[(int) sourceStr[t - 1]];
            }
            return -1;
        }        private readonly int[] delta;
        private string _pattern;
        private static readonly int DELTA_SIZE = 65536;
    }BMS bm = new BMS(s2);
            int i = bm.find(s1);
            if (i > 0) {
                Console.WriteLine("在{0}处找到（索引为0起始）!", index / 3);
            } else {
                Console.WriteLine("没找到！");
            }

Answer 15

8楼的 转E5-9B-DB 这好好的 
怎么又转UTF8做什么?

Answer 16

确实是我考虑不周，sorry。

Answer 17

300分在这里：http://topic.csdn.net/u/20090218/12/094d9464-9457-446d-9fe6-dedffc279896.html

Answer 18

class Program
    {
        static byte[] a1 ={ 3,1, 2, 3, 4, 5 };
        static byte[] a2 ={ 3, 4 };
        static int i = 0;
        static void Main(string[] args)
        {
            int index=Array.FindIndex(a1, rule);
        }        static bool rule(byte b)
        {
            i++;
            if (b != a2[0]) return false;
            else
            {
               return Convert.ToBase64String(a1, i-1, a2.Length) == Convert.ToBase64String(a2);
            }
        }
    }

Answer 19

using System;
namespace ConsoleApplication4
{
    class Program
    {
        static byte[] a1 = { 
     0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X06, 0X00, 0X00, 0X00, 0X06, 0X68, 0X73, 0X5f, 0X62, 0X61, 0X79, 0X00, 0X00, 0X00, 0X00, 0X00, 0X07, 0X00, 0X00, 0X00, 0X20, 0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X01, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X08
         };        static byte[] a2 = { 
         0X68, 0X73, 0X5f, 0X62, 0X61, 0X79 
         };
        static int i = 0;
        static void Main(string[] args)
        {
            int index = Array.FindIndex(a1, rule);//返回48
        }
        static bool rule(byte b)
        {
            i++;
            return b == a2[0] ? Convert.ToBase64String(a1, i - 1, a2.Length) == Convert.ToBase64String(a2) : false;
        }
    }
}

Answer 20

int Find()//<0 表示没找到
{
int iIndex=-1;
int iBTCnt = sizeof(mBTCmdDataBase)/sizeof(byte);
int ipattern = sizeof(pattern)/sizeof(byte); if(ipattern > iBTCnt)
return iIndex; for(int i=0;i<=iBTCnt-ipattern;i++)
{
if(mBTCmdDataBase[i] == pattern[0])
{
iIndex = i;
bool bOk = false;
for(int j=0;j<ipattern;j++)
{
if(mBTCmdDataBase[i+j] != pattern[j])
bOk = true;
}
i+=ipattern;
if(!bOk)
break;
}
}
return iIndex;
}

Answer 21

包含中文的情况下，IndexOf算出来的位置数据是错的，一个中文按一个字节计算            string mStr = "中国中国中国中国中国中国0123中国中国中国中国";
            int mPosition = mStr.IndexOf("0123");
这里mPosition 将会等于12，按照Byte来说，应该是24才对

Answer 22

int index = s1.IndexOf(s2)/3;  这样计算出来应该就对了

Answer 23

呵．．我比较懒，换了我，直接for循环得啦．

Answer 24

byte 不就是 0-255吗？应该都可以转为ASCII码吧~~~
我觉得string.indexof可行...

Answer 25

正好前两天碰到类似的问题，我是转成string后用正则表达式处理，思路如下：将数组中的每一个元素转成string -> 通过stringbuilder建立string -> 通过正则表达式来求取位置。事实上，使用正则表达式不仅可以求取第一个位置，它可以把所有匹配的数据位置都取到，并且还可以直接得到匹配数据的总数。效率方面的计算我不大懂，没有发言权。

Answer 26

// 在 s 中查找 pattern 。
// 如果找到，返回 pattern 在 s 中第一次出现的位置(0起始)。
// 如果没找到，返回 -1。
static int IndexOf(byte[] s, byte[] pattern) 
{ 
  int slen = s.Length;
  int plen = pattern.Length;
  for (int i = 0; i <= slen - plen; i++) 
  { 
    for (int j = 0; j < plen; j++) 
    { 
      if (s[i + j] != pattern[j]) break;
    }
    if (j == plen) return i;
  }
  return -1;
}

Answer 27

char *qsearch(const char *text, int n, const char *patt, int m) 
{ 
// get the length of the text and the pattern, if necessary 
if (n < 0) 
n = strlen(text); 
if (m < 0) 
m = strlen(patt); 
if (m == 0) 
return (char*)text; // construct delta shift table 
int td[128]; 
for (int c = 0; c < 128; c++) 
td[c] = m + 1; 
const char* p; 
for (p=patt; *p; p++) 
td[*p] = m - (p - patt); // start searching... 
const char *t, *tx = text; // the main searching loop 
while (tx + m <= text + n) { 
for (p = patt, t = tx; *p; ++p, ++t) { 
if (*p != *t) // found a mismatch 
break; 
} 
if (*p == 0) // Yes! we found it! 
return (char*)tx; 
tx += td[tx[m]]; // move the pattern by a distance 
} 
return NULL; 
} 
 
修改 删除 举报 引用 回复   

Answer 28

数组匹配在使用指针的情况下是比较简单的，但是在C#中不使用指针的情况下是很麻烦的，以目前来说，使用BitConverter.ToString的方法仅带来程序上的便利，但是并不是一中高效率的办法，至于这位仁兄发表的这种意见，纯粹是怨天艾人的一种表现还不结帖的原因是还想看看有没有更好的方法

Answer 29

我看51楼的程序就很高效，只不过这位仁兄对变量 j 的作用范围没有太注意，造成不能通过编译。  for (int i = 0; i <= slen - plen; i++) 
  { 
    for (int j = 0; j < plen; j++) // 应该改为：  for (int i = 0; i <= slen - plen; i++) 
  {
    int j; 
    for (j = 0; j < plen; j++) 完整的程序如下（加上数据测试）：using System;class Program
{
  static void Main()
  {
    byte[] mBTCmdDataBase =
    { 
      0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 
      0X04, 0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 
      0X00, 0X04, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X00, 0X00, 
      0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X06, 
      0X00, 0X00, 0X00, 0X06, 0X68, 0X73, 0X5f, 0X62, 0X61, 0X79, 0X00, 
      0X00, 0X00, 0X00, 0X00, 0X07, 0X00, 0X00, 0X00, 0X20, 0X00, 0X00, 
      0X00, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X01, 0X00, 
      0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X08
    };
    byte[] pattern = { 0X68, 0X73, 0X5f, 0X62, 0X61, 0X79 };
    
    int index = IndexOf(mBTCmdDataBase, pattern);    if (index >= 0)
    {
      Console.WriteLine("在{0}处找到（索引为0起始）!", index);
    }
    else
    {
      Console.WriteLine("没找到！");
    }
  }  // 在 s 中查找 pattern 。
  // 如果找到，返回 pattern 在 s 中第一次出现的位置(0起始)。
  // 如果没找到，返回 -1。
  static int IndexOf(byte[] s, byte[] pattern) 
  { 
    int slen = s.Length;
    int plen = pattern.Length;
    for (int i = 0, j; i <= slen - plen; i++) 
    { 
      for (j = 0; j < plen; j++) 
      { 
        if (s[i + j] != pattern[j]) break;
      }
      if (j == plen) return i;
    }
    return -1;
  }
}

Answer 30

C# 中固然不能使用指针（其实也不尽然，在 unsafe 代码中还是可以使用指针的），本题中完全可以使用数组下标，一样比较简单且高效。  // 在 s 中查找 pattern 。
  // 如果找到，返回 pattern 在 s 中第一次出现的位置(0起始)。
  // 如果没找到，返回 -1。
  static int IndexOf(byte[] s, byte[] pattern) 
  { 
    int slen = s.Length;
    int plen = pattern.Length;
    for (int i = 0, j; i <= slen - plen; i++) 
    { 
      for (j = 0; j < plen; j++) 
      { 
        if (s[i + j] != pattern[j]) break;
      }
      if (j == plen) return i;
    }
    return -1;
  }我认为51楼的这位仁兄的程序就很好：简单、高效，且适应各种边界条件。比如说：1. s 的长度为 0；
2. pattern 的长度为 0；
3. pattern 的长度等于 s 的长度；
4. pattern 的长度大于 s 的长度。在以上情形（或者还有其他特殊的边界条件），该程序都能迅速返回正确的结果。以情形4（plen > slen）的情况为例：    for (int i = 0, j; i <= slen - plen; i++) 相当于：    for (int i = 0, j; i <= 负数; i++) 循环一次也不执行，迅速返回 -1。
其他情形可以自己分析。
所以我推荐51楼的程序。

Answer 31

仔细思考了一下，51楼的这位仁兄的程序还是有可以改进之处的：  // 在 s 中查找 pattern 。
  // 如果找到，返回 pattern 在 s 中第一次出现的位置(0起始)。
  // 如果没找到，返回 -1。
  static int IndexOf(byte[] s, byte[] pattern) 
  { 
    int slen = s.Length;
    int plen = pattern.Length;
    for (int i = 0, j; i <= slen - plen; i++) 
    { 
      for (j = 0; j < plen; j++) 
      { 
        if (s[i + j] != pattern[j]) goto next;
      }
      return i;
      next:;
    }
    return -1;
  }
把
        if (s[i + j] != pattern[j]) break;改为：
        if (s[i + j] != pattern[j]) goto next;这样可以节省不必要的 if (j == plen) 的判断（因为用 break 退出循环时 j 肯定不等于 plen）。另外，正常退出循环时 j 肯定等于 plen ，所以循环后面的 if (j == plen) 也不是不必要的。
欢迎大家指正。

Answer 32

  // 在 s 中查找 pattern 。
  // 如果找到，返回 pattern 在 s 中第一次出现的位置(0起始)。
  // 如果没找到，返回 -1。
  static int IndexOf(byte[] s, byte[] pattern) 
  { 
    int slen = s.Length;
    int plen = pattern.Length;
    for (int i = 0; i <= slen - plen; i++) 
    { 
      for (int j = 0; j < plen; j++) 
      { 
        if (s[i + j] != pattern[j]) goto next;
      }
      return i;
      next:;
    }
    return -1;
  }使用了 goto 语句后，不必在内层循环外面判断 if (j == plen)，所以 j 的声明也就可以移回内层循环了。终点又回到了起点，呵呵。

Answer 33

用System.Array.IndexOf
int mIndex = -1;
int mIndexCurrent = -1;
byte[] mBTCmdDataBase = { 
     0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X06, 0X00, 0X00, 0X00, 0X06, 0X68, 0X73, 0X5f, 0X62, 0X61, 0X79, 0X00, 0X00, 0X00, 0X00, 0X00, 0X07, 0X00, 0X00, 0X00, 0X20, 0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X01, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X08
         };
byte[] mFinder = { 
     0X68, 0X73, 0X5f, 0X62, 0X61, 0X79
         };while (mIndex < 0)
{
    mIndex = System.Array.IndexOf(mBTCmdDataBase , mFinder[0], mIndexCurrent + 1);
    mIndexCurrent = mIndex;    if (mIndex >= 0)
    {
        for (int i = 0; i < mFinder.Length; i++)
        {
            if (mBTCmdDataBase[mIndex + i] != mFinder[i])
            {
                mIndex = -1;
                break;
            }
        }
        if (mIndex >= 0)
        {
            break;
        }
    }
}

Answer 34

System.Array旗下有很多可以使用的
纠正上面的错误int mIndex = -1;
int mIndexCurrent = -1;
byte[] mBTCmdDataBase = { 
     0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X06, 0X00, 0X00, 0X00, 0X06, 0X68, 0X73, 0X5f, 0X62, 0X61, 0X79, 0X00, 0X00, 0X00, 0X00, 0X00, 0X07, 0X00, 0X00, 0X00, 0X20, 0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X01, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X08
         };
byte[] mFinder = { 
     0X68, 0X73, 0X5f, 0X62, 0X61, 0X79
         };while (mIndex < 0)
{
    mIndex = System.Array.IndexOf(mBTCmdDataBase , mFinder[0], mIndexCurrent + 1);
    mIndexCurrent = mIndex;    if (mIndex >= 0)
    {
        for (int i = 0; i < mFinder.Length; i++)
        {
            if (mBTCmdDataBase[mIndex + i] != mFinder[i])
            {
                mIndex = -1;
                break;
            }
        }
        //if (mIndex >= 0)
        //{
        //    break;
        //}
    }
}

Answer 35

纠正上面的错误 
        public int ArrayFindIndexOf(byte [] pBT, byte [] pMatch, int pStartIndex)
        {
            try
            {
                int mIndex = -1;                while (mIndex < 0)
                {
                    mIndex = System.Array.IndexOf(pBT, pMatch[0], pStartIndex);
                    if (mIndex < pStartIndex)
                    {
                        return -1;
                    }
                    pStartIndex = mIndex + 1;                    if (mIndex >= 0)
                    {
                        for (int i = 0; i < pMatch.Length; i++)
                        {
                            if (pBT[mIndex + i] != pMatch[i])
                            {
                                mIndex = -1;
                                break;
                            }
                        }
                    }
                }
                return mIndex;
            }
            catch (NullReferenceException NullEx)
            {
                throw NullEx;
            }
            catch (Exception Ex)
            {
                throw Ex;
            }
        }

Answer 36

谢谢
System.Array.IndexOf 好像不错

Answer 37

模式匹配的KMP算法详解这种由D.E.Knuth,J.H.Morris和V.R.Pratt同时发现的改进的模式匹配算法简称为KMP算法。大概学过信息学的都知道，是个比较难理解的算法，今天特把它搞个彻彻底底明明白白。注意到这是一个改进的算法，所以有必要把原来的模式匹配算法拿出来，其实理解的关键就在这里，一般的匹配算法：int Index(String S,String T,int pos)//参考《数据结构》中的程序
{
  i=pos;j=1;//这里的串的第1个元素下标是1
  while(i<=S.Length && j<=T.Length)
  {
    if(S[i]==T[j]){++i;++j;}
    else{i=i-j+2;j=1;}//**************(1)
  }
  if(j>T.Length) return i-T.Length;//匹配成功
  else return 0;
}匹配的过程非常清晰，关键是当‘失配’的时候程序是如何处理的？回溯，没错，注意到(1)句，为什么要回溯，看下面的例子：S:aaaaabababcaaa  T:ababcaaaaabababcaaa
    ababc.(.表示前一个已经失配)
回溯的结果就是
aaaaabababcaaa
     a.(babc)
如果不回溯就是
aaaaabababcaaa
        aba.bc
这样就漏了一个可能匹配成功的情况
aaaaabababcaaa
      ababc为什么会发生这样的情况？这是由T串本身的性质决定的，是因为T串本身有前后'部分匹配'的性质。如果T为abcdef这样的，大没有回溯的必要。改进的地方也就是这里，我们从T串本身出发，事先就找准了T自身前后部分匹配的位置，那就可以改进算法。如果不用回溯，那T串下一个位置从哪里开始呢？还是上面那个例子，T为ababc，如果c失配，那就可以往前移到aba最后一个a的位置，像这样：
...ababd...
   ababc
   ->ababc这样i不用回溯，j跳到前2个位置，继续匹配的过程，这就是KMP算法所在。这个当T[j]失配后，j应该往前跳的值就是j的next值，它是由T串本身固有决定的，与S串无关。《数据结构》上给了next值的定义：
          0   如果j=1
next[j]={Max{k|1<k<j且'p1...pk-1'='pj-k+1...pj-1'
          1   其它情况我当初看到这个头就晕了，其实它就是描述的我前面表述的情况，关于next[1]=0是规定的，这样规定可以使程序简单一些，如果非要定为其它的值只要不和后面的值冲突也是可以的；而那个Max是什么意思，举个例子：T:aaab...aaaab...
   aaab
  ->aaab
   ->aaab
    ->aaab像这样的T，前面自身部分匹配的部分不止两个，那应该往前跳到第几个呢？最近的一个，也就是说尽可能的向右滑移最短的长度。OK，了解到这里，就看清了KMP的大部分内容，然后关键的问题是如何求next值？先不管它，先看如何用它来进行匹配操作，也就是说先假设已经有了next值。将最前面的程序改写成：int Index_KMP(String S,String T,int pos)
{
  i=pos;j=1;//这里的串的第1个元素下标是1
  while(i<=S.Length && j<=T.Length)
  {
    if(j==0 || S[i]==T[j]){++i;++j;} //注意到这里的j==0,和++j的作用就知道为什么规定next[1]=0的好处了
    else j=next[j];//i不变（不回溯）,j跳动
  }
  if(j>T.Length) return i-T.Length;//匹配成功
  else return 0;
}OK,是不是非常简单？还有更简单的，求next值，这也是整个算法成功的关键，从next值的定义来求太恐怖了，怎么求？前面说过了，next值表达的就是T串的自身部分匹配的性质，那么，我只要将T串和T串自身来一次匹配就可以求出来了，这里的匹配过程不是从头一个一个匹配，而是从T[1]和T[2]开始匹配，给出算法如下：void get_next(String T,int &next[])
{
  i=1;j=0;next[1]=0;
  while(i<=T.Length)
  {
    if(j==0 || T[i]==T[j]){++i;++j; next[i]=j;/**********(2)*/}
    else j=next[j];
  }
}看这个函数是不是非常像KMP匹配的函数，没错，它就是这么干的！注意到(2)语句逻辑覆盖的时候是T[i]==T[j]以及i前面的、j前面的都匹配的情况下，于是先自增，然后记下来next[i]=j，这样每当i有自增就会求得一个next[i]，而j一定会小于等于i，于是对于已经求出来的next，可以继续求后面的next，而next[1]=0是已知，所以整个就这样递推的求出来了，方法非常巧妙。这样的改进已经是很不错了，但算法还可以改进，注意到下面的匹配情况：...aaac...
   aaaa.
T串中的'a'和S串中的'c'失配，而'a'的next值指的还是'a'，那同样的比较还是会失配，而这样的比较是多余的，如果我事先知道，当T[i]==T[j]，那next[i]就设为next[j]，在求next值的时候就已经比较了，这样就可以去掉这样的多余的比较。于是稍加改进得到：void get_nextval(String T,int &next[])
{
  i=1;j=0;next[1]=0;
  while(i<=T.Length)
  {
    if(j==0 || T[i]==T[j])
    { ++i;++j;
      if(T[i]!=T[j]) next[i]=j;
      else next[i]=next[j];//消去多余的可能的比较,next再向前跳
    }
    else j=next[j];
  }
}匹配算法不变。到此就完全弄清楚了，以前老觉得KMP算法好神秘，真不是人想出来的，其实不然，它只不过是对原有的算法进行了改进。可见基础的经典的东西还是很重要，你有本事‘废’了经典，就创造了进步。

Answer 38

学习！
string.indexof.
好理解些

Answer 39

我认为 67 楼的代码不如 61 楼的代码。其实没有必要用 System.Array.IndexOf 。用 61 楼的代码应该比用 System.Array.IndexOf 效率高。

Answer 40

对于一般的数据，61 楼的算法足够好了。如果是对于下面这种变态的数据，KMP算法就有优势了，因为KMP算法不用在源串中返回，可以大大提高搜索效率。using System;class Program
{
  static void Main()
  {
   int m = 10000000;
   int n = 1000;
   byte[] s0 = new byte[m];
   byte[] s1 = new byte[n];   for (int i = 0; i < m - 1; i++) s0[i] = 1;
   for (int i = 0; i < n - 1; i++) s1[i] = 1;
   s0[m - 1] = s1[n - 1] = 2;   DateTime time0 = DateTime.Now;
   int index = IndexOf(s0, s1);
   DateTime time1 = DateTime.Now;   Console.WriteLine("index = {0}, 用时 {1} 秒", index, (time1 - time0).TotalSeconds);
   // index = 9999000, 用时 28.703125 秒
  }
 
  // 在 s 中查找 pattern 。
  // 如果找到，返回 pattern 在 s 中第一次出现的位置(0起始)。
  // 如果没找到，返回 -1。
  static int IndexOf(byte[] s, byte[] pattern) 
  {
    // ... 
  }
}

Answer 41

System.Array.IndexOf   的效率不行吗？咨询一下System.Array.IndexOf 的效率如何

Answer 42

不是 System.Array.IndexOf 的效率不行，而是应用场合不对。System.Array.IndexOf 只能搜索单个元素，而你的要求是搜索一个数组，67楼的程序用 System.Array.IndexOf 来搜索数组的第一个元素，然后还要判断数组其余元素是否匹配，如果不匹配又得重新用 System.Array.IndexOf 来搜索数组的第一个元素，....，那还不如用61楼的程序直接了当，并且效率高。
System.Array.IndexOf 用于搜索单个元素是很好的，如果要搜索一个数组，就用61楼的程序更好了。

Answer 43

      0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 
      0X04, 0X00, 0X00, 0X00, 0X03, 0X00, 0X00, 0X00, 0X04, 0X00, 0X00, 
      0X00, 0X04, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X00, 0X00, 
      0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X06, 
      0X00, 0X00, 0X00, 0X06, 0X68, 0X73, 0X5f, 0X62, 0X61, 0X79, 0X00, 
      0X00, 0X00, 0X00, 0X00, 0X07, 0X00, 0X00, 0X00, 0X20, 0X00, 0X00, 
      0X00, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X01, 0X00, 
      0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X08, 0X00, 0X00, 0X00, 0X08
上面这些都是什么意思啊 

Answer 44

System.Array.IndexOf 搜索到单个元素，再判断之后的元素是否相同，就可以完成搜索了

Answer 45

不清楚BitConverter.ToString的转换效率如何

Answer 46

多谢各位，我的评判是：
假如System.Array.IndexOf 的效率不低于For循环+if判断，则System.Array.IndexOf 是最优方案，编程也很简单
找出第一个字节相同，然后使用for循环判断之后的数据是否相同。

Answer 47

备注一下，这个程序同时要运行到PPC中，主要是针对TCP通讯数据包的识别和分割，因此比较关注效率问题

Answer 48

ToBase64String不好，因为ToBase64String会把不足某个长度的字节串后面补上若干个“=”