var validateData //you value;

if(validateData.Length<??)throw InvalidateException("Min Lenth must be 1");

validateData.Foreach(t=>t.any(范围外))//参照ascII

正则更适合注册等低频调用，除了copy方便，实际学习成本高昂~~

这和cpu有关吧，我运行上述代码在10-13之间，然后从上述代码看将创建正则表达式放在外围且设置可编译选项是性能最快的应该，想不到还有什么优化的点了。dudu老大试试如下呢，看看会不会改善一点，搞一个静态类存放创建的正则表达字段

1. 应该将var str = Guid.NewGuid().ToString();放在记时统计外面
2. 逐个字符判断，类似如下

static bool IsMatch(string s)
        {
            if (string.IsNullOrEmpty(s)) return false;
            if (s.Length > 150) return false;
            for (int i = 0; i < s.Length; i++)
            {
                char c = s[i];
                bool isValid = c >= 65 && c <= 90 ||
                    c >= 97 && c <= 122 ||
                    c >= 48 && c <= 57 ||
                    c == 45 ||
                    c == 95;
                if (!isValid) return false;
            }
            return true;
        }

想到一个 类似 bitMap 思想的方法，先把初始字母，数字，下划线，横杆。算了一下，这些的ASCII 码最大122，那么 构造一个 123 长度 的 int[] 数组 private static int[] _intBitMap = new int[123];， 先开始给这个数组初始化赋值：

 private static void InitializeBitMapData()
        {
            for (char c = 'a'; c <= 'z'; c++)
            {
                _intBitMap[c] = 1;
            }

            for (char c = 'A'; c <= 'Z'; ++c)
            {
                _intBitMap[c] = 1;
            }

            for (int i = 0; i <= 9; ++i)
            {
                _intBitMap[i] = 1;
            }

            _intBitMap[95] = 1; // _ 95
            _intBitMap[45] = 1; // - 45
        }

然后在判断时，只需要查看命中的个数，

 private static bool CalculateBitMap(string value)
        {
            var charValue = value.ToCharArray();
            var count = 0;
            for (int i = 0; i < value.Length; ++i)
            {
                count += _intBitMap[charValue[i]];
            }

            return count >= 1 && count <= 150;
        }

测试了一下，10000 的循环 大概 2-2.5 倍的差距：
截图：

使用 ReadOnlySpan ，目前找到的最快方法是 3 ticks，

class Program
{
    private const int loops = 10000;

    static void Main(string[] args)
    {
        Stopwatch sw = Stopwatch.StartNew();
        var str = Guid.NewGuid().ToString();
        for (var i = 0; i < loops; i++)
        {
            var result = str.AsSpan().ValidateWord();
        }
        sw.Stop();

        var ticks = (int)(sw.ElapsedTicks / loops);
        Console.WriteLine($"Elapsed ticks: {ticks}");
        //Output is "Elapsed ticks: 3"
    }
}

public static class CharConstraints
{
    public static bool ValidateWord(this ReadOnlySpan<char> span)
    {
        if(span.Length > 150)
        {
            return false;
        }

        foreach (var c in span)
        {
            //IsLetterDigitHyphenUnderscore
            if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_' || c == '-'))
            {
                return false;
            }
        }

        return true;
    }
}

.NET Core 版本是 3.0.100-preview8-013656 ，电脑配置是4核8G的阿里云服务器，操作系统是 Windows Server 2106

对于这种单字符的范围简单的规则，应该是硬编码算法更快。并且比正则表达式要快的多吧，毕竟正则表达式是通用算法，效率比不过有较好实现的专有算法的。算法中可以考虑通过span或者指针提高遍历字符串取字符的效率。

另外，楼主的计时算法有问题，把生成guid的时间算进去了，生成guid的时间应该比判断算法的时间大不少的。应该是先生成guid再计时。

使用 BitArray 可以有效的提高速度，只需要 8k 的内存。

在 Debug 版本下跑出来是 2 Ticks

class Program
{
    private const int loops = 10000;
    private static readonly BitArray _acceptedChars = new BitArray(char.MaxValue - char.MinValue);

    static void Main(string[] args)
    {
        for (var c = 'a'; c <= 'z'; c++)
        {
            _acceptedChars[c] = true;
        }

        for (var c = 'A'; c <= 'Z'; c++)
        {
            _acceptedChars[c] = true;
        }

        for (var c = '0'; c <= '9'; c++)
        {
            _acceptedChars[c] = true;
        }

        _acceptedChars['_'] = true;
        _acceptedChars['-'] = true;

        var testCases = new string[loops];
        for (var i = 0; i < loops; i++)
        {
            testCases[i] = Guid.NewGuid().ToString();
        }

        var result = true;
        var sw = Stopwatch.StartNew();
        for (var i = 0; i < loops; i++)
        {
            foreach (var c in testCases[i])
            {
                result = _acceptedChars[c];
            }
        }
        sw.Stop();
        Console.WriteLine($"Elapsed Ticks: {(int)(sw.ElapsedTicks / loops)}");
    }
}

我这里t440s,.net core 3.0
跑的结果是：Elapsed Ticks: 3
没发现问题呢！