U.StartWith: 00:00:00.0259870
String.StartsWith: 00:00:00.2118940

using System;

namespace ConsoleApplication1
{
    class U
    {
        public static bool StartWith(string pattern, string number)
        {
            bool match = true;
            for (int digitIndex = 0; digitIndex < pattern.Length && match; digitIndex++)
            {
                match = match && number[digitIndex].Equals(pattern[digitIndex]);
            }
            return match;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            const int max = 1000000;

            string[] myStrings = new string[max];
            string[] patterns = new string[max];
            var rnd = new Random();
            for (int i = 0; i < max; i++)
            {
                myStrings[i] = rnd.Next(1000000).ToString("{0:D6}"); // 6 digits
                patterns[i] = rnd.Next(1000).ToString(); // 1-3 digits
            }

            DateTime tU = DateTime.Now;
            for (int i = 0; i < max; i++)
            {
                U.StartWith(patterns[i], myStrings[i]);
            }
            Console.WriteLine("U.StartWith: " + (DateTime.Now - tU).ToString());

            DateTime tString = DateTime.Now;
            for (int i = 0; i < max; i++)
            {
                myStrings[i].StartsWith(patterns[i]);
            }
            Console.WriteLine("String.StartsWith: " + (DateTime.Now - tString).ToString());
        }
    }
}

U.StartWith: 00:00:00.0310000
String.StartsWith: 00:00:00.0370000

KS>Моя функция всё-равно немного быстрее.

myStrings[i].StartsWith(patterns[i], StringComparison.OrdinalIgnoreCase)

KS>>Моя функция всё-равно немного быстрее.

D>myStrings[i].StartsWith(patterns[i], StringComparison.OrdinalIgnoreCase)
D>

U.StartWith: 00:00:00.0260000
String.StartsWith: 00:00:00.1210000

                myStrings[i] = rnd.Next(1000000).ToString("{0:D6}"); // 6 digits
                patterns[i] = rnd.Next(2) == 0 ? rnd.Next(1000).ToString() : myStrings[i].Substring(3);

U.StartWith: 00:00:00.0330000
String.StartsWith: 00:00:00.0490000

U.StartWith: 00:00:00.034
String.StartsWith: 00:00:00.038

KS>>                myStrings[i] = rnd.Next(1000000).ToString("{0:D6}"); // 6 digits
KS>>                patterns[i] = rnd.Next(2) == 0 ? rnd.Next(1000).ToString() : myStrings[i].Substring(3);
KS>>

U.StartWith: 00:00:00.041
String.StartsWith: 00:00:00.052

public static class MyExtentionMethods
{
    public static bool AsciiStartsWith(this string str, string pattern)
    {
            if (pattern.Length > number.Length) return false;
            bool match = true;
            for (int digitIndex = 0; digitIndex < pattern.Length && match; digitIndex++)
            {
                match = match && number[digitIndex].Equals(pattern[digitIndex]);
            }
            return match;
    }
}

KS>public static class MyExtentionMethods
KS>{
KS>    public static bool AsciiStartsWith(this string str, string pattern)
KS>    {
KS>            if (pattern.Length > number.Length) return false;
KS>            bool match = true;
KS>            for (int digitIndex = 0; digitIndex < pattern.Length && match; digitIndex++)
KS>            {
KS>                match = match && number[digitIndex].Equals(pattern[digitIndex]);
KS>            }
KS>            return match;
KS>    }
KS>}

for(var i = 0; i < pattern.Length; i++) {
  if(!number[i].Equals(pattern[i])) {
    return false;
  }//if
}//for
return true;

___>

private static extern unsafe int nativeCompareOrdinalIgnoreCaseEx(void* pNativeTextInfo, string strA, int indexA, string strB, int indexB, int length);