在byte[]和string中查找byte[]的速度，为什么后者更快

我有一个任务，我需要在文件中查找序列。在做测试应用程序时，我已经将文件读取为字符串(file . readalltext)并使用字符串。IndexOf查找一个序列。当我尝试用字节实现相同的算法(将文件读取为字节数组并在字节数组中查找字节数组)时，我注意到在byte[]中查找byte[]的速度大约是在string中查找string的3倍。我确保彻底检查了它，完全相同的代码，一个使用byte[]，另一个使用string，需要3倍的时间来执行-例如，16秒字节vs ~5秒字符串。

对于查找字节数组，我使用这里描述的byte[]数组模式搜索方法。为了查找字符串，我使用了字符串类的内置IndexOf函数。下面是我尝试过的用于byte[]的IndexOf的实现之一:

    public int IndexOf(byte[] source, byte[] pattern, int startpos = 0)
    {
        int search_limit = source.Length - pattern.Length;
        for (int i = startpos; i < search_limit; i++)
        {
            if (source[i] == pattern[0])
            {
                bool found = true;
                for (int j = 1; j < pattern.Length; j++)
                {
                    if (source[i + j] != pattern[j])
                    {
                        found = false;
                        break;
                    }
                }
                if (found)
                    return i;
            }
        }
        return -1;
    }

基本上，在bytes数组中查找下一个匹配的字节序列需要的时间是在string中查找下一个匹配的字符序列的三倍。我的问题是——为什么?

有没有人知道。net如何处理查找字符串中的字符，它做了什么样的优化，它使用什么算法?有没有比我现在用的更快的算法?也许有人知道我哪里做错了所以花了太多时间?我真的不明白为什么在string中查找string可以比在byte[]中查找byte[]快3倍…

UPDATE:我已经按照建议尝试了不安全的算法。内容如下:

public static unsafe long IndexOfFast(byte[] Haystack, byte[] Needle, long startpos = 0)
    {
        long i = startpos;
        fixed (byte* H = Haystack) fixed (byte* N = Needle)
        {
            for (byte* hNext = H + startpos, hEnd = H + Haystack.LongLength; hNext < hEnd; i++, hNext++)
            {
                    bool Found = true;
                    for (byte* hInc = hNext, nInc = N, nEnd = N + Needle.LongLength; Found && nInc < nEnd; Found = *nInc == *hInc, nInc++, hInc++) ;
                    if (Found) return i;
            }
            return -1;
        }
    }
}

奇怪的是，它实际上被证明是慢两倍!我将其更改为添加我个人的调整(在尝试遍历指针之前检查第一个字母)，现在看起来像这样:

public static unsafe long IndexOfFast(byte[] Haystack, byte[] Needle, long startpos = 0)
    {
        long i = startpos;
        fixed (byte* H = Haystack) fixed (byte* N = Needle)
        {
            for (byte* hNext = H + startpos, hEnd = H + Haystack.LongLength; hNext < hEnd; i++, hNext++)
            {
                if (*hNext == *N)
                {
                    bool Found = true;
                    for (byte* hInc = hNext+1, nInc = N+1, nEnd = N + Needle.LongLength; Found && nInc < nEnd; Found = *nInc == *hInc, nInc++, hInc++) ;
                    if (Found) return i;
                }
            }
            return -1;
        }
    }

现在，它的执行时间与安全的完全相同。我的问题是，知道为什么吗?难道它不应该更快吗，因为它是不安全的，并且与指针操作，与安全相比?