小编点评

本文介绍了一种在 .NET Core 中实现高性能和零内存分配的 LikeString 函数。该函数旨在减少内存分配和提高性能，支持 * 和 ? 通配符，并忽略大小写规则和区域性。 1. 引言 本文首先介绍了 LikeString 函数的作用，即模仿 Microsoft.VisualBasic.CompilerServices.LikeOperator.LikeString 方法，实现支持 * 和 ? 通配符、忽略大小写规则和区域性匹配。 2. 实现方法 作者分享了四种实现方式，但它们在性能和内存分配方面均不理想。因此，作者提出了使用 ReadOnlySpan 结构类型的解决方案。 3. 代码解析 文章详细解析了 LikeString 函数的实现过程，包括对输入参数的处理、通配符匹配、字符匹配等关键部分。 4. 性能优化 作者提到了一种新的实现方法，利用 ReadOnlySpan 结构类型来避免内存分配，从而提高性能。 5. 结论 最后，作者总结了以上内容，并提供了相关代码示例，以便在 .NET Standard 2.1 项目和 .NET Standard 2.0 项目中使用。 通过使用 ReadOnlySpan 结构类型，我们可以在 .NET Core 中实现高性能和零内存分配的 LikeString 函数，从而提高应用程序的性能和用户体验。

正文

继上一篇文章在.NET Core，除了VB的LikeString，还有其它方法吗？(四种LikeString实现分享)分享了四种实现方式，笔者对这四种实现方式，不管是执行性能还是内存分配性能上，都不太满意。

那么是否有好的实现方法呢？答案是有的。

今天我们就搬出ReadOnlySpan<T>这个非常好用的结构类型，它是在 .NET Core 2.1 中新引入的类型，与它一同被引入的类型还有：

• System.Span: 这以类型安全和内存安全的方式表示任意内存的连续部分；
• System.ReadOnlySpan: 这表示任意连续内存区域的类型安全和内存安全只读表示形式；
• System.Memory: 这表示一个连续的内存区域；
• System.ReadOnlyMemory: 类似ReadOnlySpan, 此类型表示内存的连续部分ReadOnlySpan, 它不是 ByRef 类型；

  注：ByRef 类型指的是 ref readonly struct。

下面，我们就来看看如何实现高性能和零内存分配的 LikeString 函数吧！

#nullable enable

using System;

namespace AllenCai
{
    /// <summary>
    /// 这是一个模仿Microsoft.VisualBasic.CompilerServices.LikeOperator.LikeString方法，<br />
    /// 实现支持*和?通配符和支持忽略大小写规则以及区域无关性的匹配。<br />
    /// 该实现的目的是为了减少内存分配，提高性能。
    /// </summary>
    public class ZeroMemAllocLikeOperator
    {
        /// <summary>
        /// 对给定的两个字符串执行比较，支持使用*和?通配符。
        /// </summary>
        public static bool LikeString(string? content, string? pattern, bool ignoreCase = true, bool useInvariantCulture = true)
        {
            if (content == null && pattern == null)
                return true;
            if (content == null || pattern == null)
                return false;

            ReadOnlySpan<char> patternSpan = pattern.AsSpan();
            ReadOnlySpan<char> contentSpan = content.AsSpan();

            return LikeString(contentSpan, patternSpan, ignoreCase, useInvariantCulture);
        }

        /// <summary>
        /// 对给定的两个字符Span执行比较，支持使用*和?通配符。
        /// </summary>
        public static bool LikeString(ReadOnlySpan<char> contentSpan, ReadOnlySpan<char> patternSpan, bool ignoreCase = true, bool useInvariantCulture = true)
        {
            char zeroOrMoreChars = '*';
            char oneChar = '?';

            // 如果pattern是由1个星号*组成，那么没必要匹配，直接返回true。
            if (patternSpan.Length == 1)
            {
                ref readonly char patternItem = ref patternSpan[0];
                if (patternItem == zeroOrMoreChars)
                {
                    return true;
                }
            }

            // 如果被匹配内容的长度只有1位，而pattern刚好也是一个问号?，那么没必要匹配，直接返回true。
            if (contentSpan.Length == 1)
            {
                ref readonly char patternItem = ref patternSpan[0];
                if (patternItem == oneChar)
                {
                    return true;
                }
            }

            // 如果pattern是由多个星号*和问号?组成，那么没必要匹配，直接返回true。
            int zeroOrMorePatternCount = 0;
            int onePatternCount = 0;
            for (int i = 0; i < patternSpan.Length; i++)
            {
                ref readonly char patternItem = ref patternSpan[i];
                if (patternItem == zeroOrMoreChars)
                {
                    zeroOrMorePatternCount++;
                }
                else if (patternItem == oneChar)
                {
                    onePatternCount++;
                }
            }
            if (zeroOrMorePatternCount + onePatternCount == patternSpan.Length)
            {
                //只要出现1个或多个星号*，那么就没必要在乎被匹配内容的长度了。
                if (zeroOrMorePatternCount > 0)
                {
                    return true;
                }

                //如果没有星号*，全是问号?，那么就检查是否由问号?组成的pattern长度是否和被匹配内容的长度一致。如果一致，没必要匹配，直接返回true。
                if (patternSpan.Length == contentSpan.Length)
                {
                    return true;
                }
            }

            // 选择合适的EqualsChar方法。
            EqualsCharDelegate equalsChar;
            if (ignoreCase)
            {
                if (useInvariantCulture)
                {
                    equalsChar = EqualsCharInvariantCultureIgnoreCase;
                }
                else
                {
                    equalsChar = EqualsCharCurrentCultureIgnoreCase;
                }
            }
            else
            {
                equalsChar = EqualsChar;
            }

            return LikeStringCore(contentSpan, patternSpan, in zeroOrMoreChars, in oneChar, equalsChar);
        }

        private static bool LikeStringCore(ReadOnlySpan<char> contentSpan, ReadOnlySpan<char> patternSpan, in char zeroOrMoreChars, in char oneChar, EqualsCharDelegate equalsChar)
        {
            // 遍历pattern，逐个字符匹配。
            int contentIndex = 0;
            int patternIndex = 0;
            while (contentIndex < contentSpan.Length && patternIndex < patternSpan.Length)
            {
                ref readonly char patternItem = ref patternSpan[patternIndex];
                if (patternItem == zeroOrMoreChars)
                {
                    // 如果pattern中的下一个字符是星号*，那么就一直往后移动patternIndex，直到找到不是星号*的字符。
                    while (true)
                    {
                        if (patternIndex < patternSpan.Length)
                        {
                            ref readonly char nextPatternItem = ref patternSpan[patternIndex];
                            if (nextPatternItem == zeroOrMoreChars)
                            {
                                patternIndex++;
                                continue;
                            }
                        }
                        break;
                    }

                    // 如果patternIndex已经到了pattern的末尾，那么就没必要再匹配了，直接返回true。
                    if (patternIndex == patternSpan.Length)
                    {
                        return true;
                    }

                    // 如果patternIndex还没到pattern的末尾，那么就从contentIndex开始匹配。
                    while (contentIndex < contentSpan.Length)
                    {
                        if (LikeStringCore(contentSpan.Slice(contentIndex), patternSpan.Slice(patternIndex), in zeroOrMoreChars, in oneChar, equalsChar))
                        {
                            return true;
                        }
                        contentIndex++;
                    }

                    return false;
                }

                if (patternItem == oneChar)
                {
                    // 如果pattern中的下一个字符是问号?，那么就匹配一个字符。
                    contentIndex++;
                    patternIndex++;
                }
                else
                {
                    // 如果pattern中的下一个字符不是星号*，也不是问号?，那么就匹配一个字符。
                    if (contentIndex >= contentSpan.Length)
                    {
                        return false;
                    }

                    ref readonly char contentItem = ref contentSpan[contentIndex];
                    if (!equalsChar(in contentItem, in patternItem))
                    {
                        return false;
                    }

                    //if (ignoreCase)
                    //{
                    //    if (char.ToUpperInvariant(contentItem) != char.ToUpperInvariant(patternItem))
                    //    {
                    //        return false;
                    //    }
                    //}
                    //else
                    //{
                    //    if (contentItem != patternItem)
                    //    {
                    //        return false;
                    //    }
                    //}

                    contentIndex++;
                    patternIndex++;
                }
            }

            // 如果content都匹配完了，而pattern还没遍历完，则检查剩余的patternItem是否都是星号*，如果是就返回true，否则返回false。
            if (contentIndex == contentSpan.Length)
            {
                // 如果pattern中的下一个字符是星号*，那么就一直往后移动patternIndex，直到找到不是星号*的字符。
                while (true)
                {
                    if (patternIndex < patternSpan.Length)
                    {
                        ref readonly char nextPatternItem = ref patternSpan[patternIndex];
                        if (nextPatternItem == zeroOrMoreChars)
                        {
                            patternIndex++;
                            continue;
                        }
                    }
                    break;
                }

                return patternIndex == patternSpan.Length;
            }

            return false;
        }

        private static bool EqualsChar(in char contentItem, in char patternItem)
        {
            return contentItem == patternItem;
        }

        private static bool EqualsCharCurrentCultureIgnoreCase(in char contentItem, in char patternItem)
        {
            return char.ToUpper(contentItem) == char.ToUpper(patternItem);
        }

        private static bool EqualsCharInvariantCultureIgnoreCase(in char contentItem, in char patternItem)
        {
            return char.ToUpperInvariant(contentItem) == char.ToUpperInvariant(patternItem);
        }

        private delegate bool EqualsCharDelegate(in char contentItem, in char patternItem);
    }
}

PS: 以上代码在 .NET Standard 2.1 项目使用，可直接编译通过。

在 .NET Standard 2.0 项目中，需要额外引入 System.Memory 这个 NuGet 包，且需要将 LangVersion（C#语言版本）更改为 8.0 或更高（通常使用default或latest也可以）。