public static dynamic ToQueryObject(this string query)
{
    if (query == null || string.IsNullOrWhiteSpace(query)) return null;

    IDictionary<string, object> obj = null;
    var collection = HttpUtility.ParseQueryString(query);
    for (int i = 0; i < collection.Keys.Count; i++)
    {
        // 偷懒的写法，解析后再合并，相对容易理解
        var key = collection.Keys[i];
        var values = collection.GetValues(key);
        obj = obj.Combine(GetDictionary(key, values));
    }

    return obj;
}

private static IDictionary<string, object> GetDictionary(string key, string[] values)
{
    if (key == null)
    {
        throw new ArgumentNullException(nameof(key));
    }

    // 用于匹配属性或数组的正则
    var regex = new Regex(@"^(?<n1>[^\[\]]+?)(?<n2>(\[([^\[\]]+?)\])*)(?<n3>\[\])?$");
    var match = regex.Match(key);

    if (!match.Success)
    {
        throw new Exception($"Property \"{key}\" failed to match.");
    }
    else
    {
        // 解析 Key 内容
        var firstKey = match.Result("${n1}");
        var lastKey = match.Result("${n2}");
        bool isAarry = match.Result("${n3}") == "[]";

        if (!isAarry && values.Length > 1)
        {
            throw new Exception($"Property \"{key}\" value are not allowed to be arrays.");
        }
        else
        {
            object value = isAarry ? new List<object>(values) : (values.Length > 0 && !string.IsNullOrEmpty(values[0]) ? values[0] : null);

            // 属性路径上所有的内容
            var keys = new List<string> { firstKey };
            if (!string.IsNullOrEmpty(lastKey))
            {
                keys.AddRange(lastKey.Trim('[', ']').Split("]["));
            }

            // 由内向外迭代赋值
            for (int i = keys.Count - 1; i >= 0; i--)
            {
                if (i != 0 && int.TryParse(keys[i], out var index))
                {
                    // 如果是数字则说明是索引
                    var list = new List<object>(new object[index + 1]);
                    list[index] = value;
                    value = list;
                }
                else
                {
                    // 否则说明是属性
                    IDictionary<string, object> dict = new ExpandoObject();
                    dict.TryAdd(keys[i], value);
                    value = dict;
                }
            }

            return value as IDictionary<string, object>;
        }
    }
}

private static IDictionary<string, object> Combine(this IDictionary<string, object> target, IDictionary<string, object> from)
{
    if (target == null)
    {
        target = from;
    }
    else if (target != null && from != null)
    {
        foreach (var fromItem in from)
        {
            if (fromItem.Value == null) continue;
            if (target.TryGetValue(fromItem.Key, out object targetValue) && targetValue != null)
            {
                if (targetValue is List<object> targetList && fromItem.Value is List<object> fromList)
                {
                    // 合并集合
                    var list = targetList.Combine(fromList);
                    target[fromItem.Key] = list;
                }
                else if (targetValue is IDictionary<string, object> targetDict && fromItem.Value is IDictionary<string, object> fromDict)
                {
                    // 合并字典
                    var dict = targetDict.Combine(fromDict);
                    target[fromItem.Key] = dict;
                }
                else
                {
                    throw new Exception($"Type \"{targetValue.GetType()}\" and type \"{fromItem.Value.GetType()}\" cannot be merged.");
                }
            }
            else
            {
                target[fromItem.Key] = fromItem.Value;
            }
        }
    }

    return target;
}

private static List<object> Combine(this List<object> target, List<object> from)
{
    if (target == null)
    {
        target = from;
    }
    else if (target != null && from != null)
    {
        for (int i = 0; i < Math.Max(target.Count, from.Count); i++)
        {
            var targetItem = target.Count > i ? target[i] : null;
            var fromItem = from.Count > i ? from[i] : null;
            if (targetItem == null || fromItem == null)
            {
                var value = targetItem ?? fromItem;
                if (target.Count > i) target[i] = value;
                else target.Add(value);
            }
            else if (targetItem is List<object> targetList && fromItem is List<object> fromList)
            {
                // 合并集合
                var list = targetList.Combine(fromList);
                if (target.Count > i) target[i] = list;
                else target.Add(list);
            }
            else if (targetItem is IDictionary<string, object> targetDict && fromItem is IDictionary<string, object> fromDict)
            {
                // 合并字典
                var dict = targetDict.Combine(fromDict);
                if (target.Count > i) target[i] = dict;
                else target.Add(dict);
            }
            else
            {
                throw new Exception($"Type \"{targetItem.GetType()}\" and type \"{fromItem.GetType()}\" cannot be merged.");
            }
        }
    }

    return target;
}

var query = "c%5B0%5D%5B%5D=1&c%5B0%5D%5B%5D=2&c%5B0%5D%5B%5D=3&c%5B1%5D%5B%5D=4&c%5B1%5D%5B%5D=5&c%5B1%5D%5B%5D=6&c%5B1%5D%5B3%5D%5Bd%5D=1&c%5B1%5D%5B3%5D%5Be%5D=2";
var obj = query.ToQueryObject();
var json = JsonConvert.SerializeObject(obj, Formatting.Indented);

// 输出内容为：
// {
//   "c": [
//     [
//       "1",
//       "2",
//       "3"
//     ],
//     [
//       "4",
//       "5",
//       "6",
//       {
//         "d": "1",
//         "e": "2"
//       }
//     ]
//   ]
// }

public static string ToQueryString<T>(this T @this) where T : class
{
    var queries = ToQueryString("", JToken.FromObject(@this));
    return queries.Any() ? $"?{string.Join("&", queries)}" : "";
}

private static IEnumerable<string> ToQueryString(string prefix, JToken token)
{
    if (token is JObject obj)
    {
        foreach (var property in obj.Properties())
        {
            var subToken = obj[property.Name];
            var name = string.IsNullOrEmpty(prefix) ? property.Name : $"{prefix}[{property.Name}]";
            foreach (var item in ToQueryString(name, subToken))
            {
                yield return item;
            }
        }
    }
    else if (!string.IsNullOrEmpty(prefix))
    {
        if (token is JValue value)
        {
            yield return $"{Uri.EscapeDataString(prefix)}={Uri.EscapeDataString(value.ToString())}";
        }
        else if (token is JArray array)
        {
            for (int i = 0; i < array.Count; i++)
            {
                var subToken = array[i];
                var name = $"{prefix + (subToken is JValue ? "[]" : $"[{i}]")}";
                foreach (var item in ToQueryString(name, array[i]))
                {
                    yield return item;
                }
            }
        }
    }
}

var obj = new
{
    c = new object[]
    {
        new[] { 1, 2, 3, },
        new object[]
        { 
            4, 5, 6,
            new
            {
                d = 1,
                e = 2
            }
        }
    }
};
var query = obj.ToQueryString();

// 输出内容为：
// ?c%5B0%5D%5B%5D=1&c%5B0%5D%5B%5D=2&c%5B0%5D%5B%5D=3&c%5B1%5D%5B%5D=4&c%5B1%5D%5B%5D=5&c%5B1%5D%5B%5D=6&c%5B1%5D%5B3%5D%5Bd%5D=1&c%5B1%5D%5B3%5D%5Be%5D=2

public class Person
{
    [JsonProperty("first_name")]
    public string FirstName { get; set; }

    [JsonProperty("last_name")]
    public string LastName { get; set; }

    [JsonProperty("full_name")]
    public string FullName { get; set; }

    [JsonProperty("age")]
    public int? Age { get; set; }
}

var obj = new Person
{
    FirstName = "John",
    LastName = "Sun",
    FullName = "John Sun",
    Age = 3
};
var query = obj.ToQueryString();

// 输出内容为：
// ?first_name=John&last_name=Sun&full_name=John%20Sun&age=3

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using PluralizeService.Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace Utils
{
    /// <summary>
    /// Json 工具类
    /// </summary>
    public static class JsonUtil
    {
        /// <summary>
        /// 将 Json 内容转换为 C# 实体类
        /// </summary>
        /// <param name="json">json 内容</param>
        /// <returns>转化后的实体类内容</returns>
        public static string ToEntityClass(string json)
        {
            var obj = JsonConvert.DeserializeObject(json);

            var entities = new Dictionary<string, EntityInfo>();
            MapEntityInfo("BaseEntity", entities, obj as JToken);

            var content = new StringBuilder();

            foreach (var entity in entities)
            {
                // 开始
                content.AppendLine($"public class {PluralizationProvider.Singularize(GetPascalName(entity.Key))}");
                content.AppendLine("{");

                foreach (var property in entity.Value.Properties)
                {
                    content.AppendLine($"    [JsonProperty(\"{property.Key}\")]");
                    content.AppendLine($"    public {GetTypeName(property.Value)} {GetPascalName(property.Key)} {{ get; set; }}");
                    content.AppendLine();
                }

                // 结束
                content.AppendLine("}");
                content.AppendLine();
            }

            return content.ToString();
        }

        private static string GetTypeName(PropertyInfo property)
        {
            string name = property.Type;
            var type = Type.GetType(name, false);
            var typeNameMap = new TypeNameMap();
            return $"{(property.IsArray ? "List<" : "")}{(type != null ? (typeNameMap[type.Name] ?? type.Name) : PluralizationProvider.Singularize(GetPascalName(name)))}{(property.Nullable && type != null && type.IsSubclassOf(typeof(ValueType)) ? "?" : "")}{(property.IsArray ? ">" : "")}";
        }

        private static string GetPascalName(string name)
        {

            if (string.IsNullOrEmpty(name)) return string.Empty;

            // 匹配 特殊字符+小写字母
            var regex = new Regex("[^0-9a-zA-Z]+([0-9a-zA-Z]{1})");
            var matches = regex.Matches(name);
            foreach (Match match in matches)
            {
                name = name.Replace(match.Value, match.Result("$1").ToUpper());
            }

            // 移除非数字、字母的内容
            name = new Regex("[^0-9a-zA-Z]+").Replace(name, string.Empty);

            // 首字母转大写
            if (name.Length > 0) name = string.Concat(name.Substring(0, 1).ToUpper(), name.Substring(1));

            return name;
        }

        private static EntityInfo MapEntityInfo(string name, Dictionary<string, EntityInfo> entities, JToken token)
        {
            // 获取实体信息
            if (!entities.TryGetValue(name, out EntityInfo entity))
            {
                entity = new EntityInfo();
                entities.TryAdd(name, entity);
            }

            // 实体的属性信息
            var properties = entity.Properties;

            if (token is JObject obj)
            {
                // 内容是对象时，需要获取属性信息
                foreach (var kv in obj)
                {
                    string key = kv.Key;
                    var value = kv.Value;
                    if (!properties.TryGetValue(key, out PropertyInfo property))
                    {
                        property = new PropertyInfo();
                        property.Name = key;
                        properties.TryAdd(key, property);
                    }

                    if (value != null)
                    {
                        if (value is JValue jValue)
                        {
                            switch (jValue.Type)
                            {
                                case JTokenType.Integer:
                                    property.Type = typeof(long).FullName;
                                    break;
                                case JTokenType.Float:
                                    property.Type = typeof(decimal).FullName;
                                    break;
                                case JTokenType.Null:
                                case JTokenType.String:
                                    property.Type = typeof(string).FullName;
                                    break;
                                case JTokenType.Boolean:
                                    property.Type = typeof(bool).FullName;
                                    break;
                                case JTokenType.Date:
                                    property.Type = typeof(DateTime).FullName;
                                    break;
                                case JTokenType.Guid:
                                    property.Type = typeof(Guid).FullName;
                                    break;
                                case JTokenType.Uri:
                                    property.Type = typeof(Uri).FullName;
                                    break;
                                case JTokenType.TimeSpan:
                                    property.Type = typeof(TimeSpan).FullName;
                                    break;
                                default:
                                    throw new Exception("解析数值出现未知的数据类型！");
                            }
                        }
                        else if (value is JArray jArray)
                        {
                            property.IsArray = true;
                            property.Nullable = jArray.Any(a => a.Type == JTokenType.Null);
                            if (jArray.Count > 0 && jArray.Any(a => a.Type != JTokenType.Null))
                            {
                                var firstType = jArray.First(a => a.Type != JTokenType.Null).Type;
                                if (jArray.Any(a => a.Type != firstType && a.Type != JTokenType.Null))
                                {
                                    throw new Exception("解析数组成员类型不唯一！");
                                }

                                switch (firstType)
                                {
                                    case JTokenType.Object:
                                        property.Type = key;
                                        foreach (var item in jArray.Where(a => a.Type == JTokenType.Object))
                                        {
                                            MapEntityInfo(key, entities, item);
                                        }
                                        break;
                                    case JTokenType.Integer:
                                        property.Type = typeof(long).FullName;
                                        break;
                                    case JTokenType.Float:
                                        property.Type = typeof(decimal).FullName;
                                        break;
                                    case JTokenType.String:
                                        property.Type = typeof(string).FullName;
                                        break;
                                    case JTokenType.Boolean:
                                        property.Type = typeof(bool).FullName;
                                        break;
                                    case JTokenType.Date:
                                        property.Type = typeof(DateTime).FullName;
                                        break;
                                    case JTokenType.Guid:
                                        property.Type = typeof(Guid).FullName;
                                        break;
                                    case JTokenType.Uri:
                                        property.Type = typeof(Uri).FullName;
                                        break;
                                    case JTokenType.TimeSpan:
                                        property.Type = typeof(TimeSpan).FullName;
                                        break;
                                    default:
                                        throw new Exception("解析数组出现未知的数据类型！");
                                }
                            }
                        }
                        else
                        {
                            property.Type = key;
                            MapEntityInfo(key, entities, value);
                        }
                    }
                    else
                    {
                        property.Nullable = true;
                    }
                }
            }

            return entity;
        }
    }

    class EntityInfo
    {
        public string Name { get; set; }

        public Dictionary<string, PropertyInfo> Properties { get; set; } = new Dictionary<string, PropertyInfo>();
    }

    class PropertyInfo
    {
        public string Name { get; set; }

        public string Type { get; set; } = typeof(string).FullName;

        public bool IsArray { get; set; }

        public bool Nullable { get; set; }
    }

    class TypeNameMap
    {
        private static readonly Dictionary<string, string> typeNameMap = new()
        {
            [typeof(bool).Name] = "bool",
            [typeof(byte).Name] = "byte",
            [typeof(sbyte).Name] = "sbyte",
            [typeof(short).Name] = "short",
            [typeof(ushort).Name] = "ushort",
            [typeof(int).Name] = "int",
            [typeof(uint).Name] = "uint",
            [typeof(long).Name] = "long",
            [typeof(ulong).Name] = "ulong",
            [typeof(float).Name] = "float",
            [typeof(double).Name] = "double",
            [typeof(decimal).Name] = "decimal",
            [typeof(string).Name] = "string",
        };

        internal string this[string name]
        {
            get
            {
                typeNameMap.TryGetValue(name, out string value);
                return value;
            }
        }
    }
}

public class BaseEntity
{
    [JsonProperty("ProductInfoList")]
    public List<ProductInfoList> ProductInfoList { get; set; }

    [JsonProperty("PageIndex")]
    public long PageIndex { get; set; }

    [JsonProperty("TotalCount")]
    public long TotalCount { get; set; }

    [JsonProperty("PageTotal")]
    public long PageTotal { get; set; }

    [JsonProperty("PageSize")]
    public long PageSize { get; set; }

}

public class ProductInfoList
{
    [JsonProperty("Sku")]
    public string Sku { get; set; }

    [JsonProperty("CategoryFirstCode")]
    public string CategoryFirstCode { get; set; }

    [JsonProperty("CategoryFirstName")]
    public string CategoryFirstName { get; set; }

    [JsonProperty("CategoryFirstNameEN")]
    public string CategoryFirstNameEN { get; set; }

    [JsonProperty("CategorySecondCode")]
    public string CategorySecondCode { get; set; }

    [JsonProperty("CategorySecondName")]
    public string CategorySecondName { get; set; }

    [JsonProperty("CategorySecondNameEN")]
    public string CategorySecondNameEN { get; set; }

    [JsonProperty("CategoryThirdCode")]
    public string CategoryThirdCode { get; set; }

    [JsonProperty("CategoryThirdName")]
    public string CategoryThirdName { get; set; }

    [JsonProperty("CategoryThirdNameEN")]
    public string CategoryThirdNameEN { get; set; }

    [JsonProperty("CnName")]
    public string CnName { get; set; }

    [JsonProperty("EnName")]
    public string EnName { get; set; }

    [JsonProperty("SpecLength")]
    public decimal SpecLength { get; set; }

    [JsonProperty("SpecWidth")]
    public decimal SpecWidth { get; set; }

    [JsonProperty("SpecHeight")]
    public decimal SpecHeight { get; set; }

    [JsonProperty("SpecWeight")]
    public decimal SpecWeight { get; set; }

    [JsonProperty("Published")]
    public bool Published { get; set; }

    [JsonProperty("IsClear")]
    public bool IsClear { get; set; }

    [JsonProperty("FreightAttrCode")]
    public string FreightAttrCode { get; set; }

    [JsonProperty("FreightAttrName")]
    public string FreightAttrName { get; set; }

    [JsonProperty("PlatformCommodityCode")]
    public string PlatformCommodityCode { get; set; }

    [JsonProperty("CommodityWarehouseMode")]
    public long CommodityWarehouseMode { get; set; }

    [JsonProperty("GoodsImageList")]
    public List<GoodsImageList> GoodsImageList { get; set; }

    [JsonProperty("GoodsAttachmentList")]
    public List<string> GoodsAttachmentList { get; set; }

    [JsonProperty("GoodsDescriptionList")]
    public List<GoodsDescriptionList> GoodsDescriptionList { get; set; }

    [JsonProperty("CreateTime")]
    public DateTime CreateTime { get; set; }

    [JsonProperty("UpdateTime")]
    public DateTime UpdateTime { get; set; }

    [JsonProperty("TortInfo")]
    public TortInfo TortInfo { get; set; }

    [JsonProperty("IsProductAuth")]
    public bool IsProductAuth { get; set; }

    [JsonProperty("ProductSiteModelList")]
    public List<ProductSiteModelList> ProductSiteModelList { get; set; }

    [JsonProperty("BrandName")]
    public string BrandName { get; set; }

}

public class GoodsImageList
{
    [JsonProperty("ImageUrl")]
    public string ImageUrl { get; set; }

    [JsonProperty("ThumbnailUrl")]
    public string ThumbnailUrl { get; set; }

    [JsonProperty("Sort")]
    public long Sort { get; set; }

    [JsonProperty("IsMainImage")]
    public bool IsMainImage { get; set; }

    [JsonProperty("GooodsThumbnailList")]
    public List<GooodsThumbnailList> GooodsThumbnailList { get; set; }

}

public class GooodsThumbnailList
{
    [JsonProperty("StandardLength")]
    public long StandardLength { get; set; }

    [JsonProperty("StandardWidth")]
    public long StandardWidth { get; set; }

    [JsonProperty("StandardImageUrl")]
    public string StandardImageUrl { get; set; }

}

public class GoodsDescriptionList
{
    [JsonProperty("Title")]
    public string Title { get; set; }

    [JsonProperty("GoodsDescriptionKeywordList")]
    public List<GoodsDescriptionKeywordList> GoodsDescriptionKeywordList { get; set; }

    [JsonProperty("GoodsDescriptionLabelList")]
    public List<GoodsDescriptionLabelList> GoodsDescriptionLabelList { get; set; }

    [JsonProperty("GoodsDescriptionParagraphList")]
    public List<GoodsDescriptionParagraphList> GoodsDescriptionParagraphList { get; set; }

}

public class GoodsDescriptionKeywordList
{
    [JsonProperty("KeyWord")]
    public string KeyWord { get; set; }

}

public class GoodsDescriptionLabelList
{
    [JsonProperty("LabelName")]
    public string LabelName { get; set; }

}

public class GoodsDescriptionParagraphList
{
    [JsonProperty("ParagraphName")]
    public string ParagraphName { get; set; }

    [JsonProperty("SortNo")]
    public long SortNo { get; set; }

    [JsonProperty("GoodsDescription")]
    public string GoodsDescription { get; set; }

}

public class TortInfo
{
    [JsonProperty("TortReasons")]
    public string TortReasons { get; set; }

    [JsonProperty("TortTypes")]
    public string TortTypes { get; set; }

    [JsonProperty("TortStatus")]
    public long TortStatus { get; set; }

}

public class ProductSiteModelList
{
    [JsonProperty("SiteHosts")]
    public string SiteHosts { get; set; }

    [JsonProperty("WarehouseCodeList")]
    public List<string> WarehouseCodeList { get; set; }

}

/// <summary>
/// 拼音五笔帮助类
/// </summary>
public static class PinyinWubiHelper
{
    private static Dictionary<char, (char[] pinyin, char[] wubi)> _dicHanzi = new Dictionary<char, (char[] pinyin, char[] wubi)>();
    static PinyinWubiHelper()
    {
        string text = Resource.chinese;
        // 记录没有五笔或拼音的字符，存在需要抛出异常
        List<char> listWubi = new List<char>();
        List<char> listPinyin = new List<char>();
        foreach (string hanzi in text.Split('\n', StringSplitOptions.RemoveEmptyEntries))
        {
            string[] info = hanzi.Split(',');
            _dicHanzi.Add(info[0][0]
                , (pinyin: info[2].Split('|', StringSplitOptions.RemoveEmptyEntries).Select(py => py[0]).ToArray()
                , wubi: info[1].Split('|', StringSplitOptions.RemoveEmptyEntries).Select(wb => wb[0]).ToArray()));
            if (_dicHanzi[info[0][0]].wubi.Length == 0) listWubi.Add(info[0][0]);
            if (_dicHanzi[info[0][0]].pinyin.Length == 0) listPinyin.Add(info[0][0]);
        }
        if (listWubi.Count > 0 || listPinyin.Count > 0)
        {
            throw new Exception($"{(listWubi.Count > 0 ? $"存在无五笔首码的字符：{string.Concat(listWubi)}" : "")}\r\n{(listPinyin.Count > 0 ? $"存在无拼音首码的字符：{string.Concat(listPinyin)}" : "")}");
        }
    }
 
    /// <summary>
    /// 获取一段中文的五笔首码
    /// </summary>
    /// <param name="text">中文内容</param>
    /// <param name="length">期望返回五笔首码的最大长度，默认 20</param>
    /// <returns>处理后的五笔首码</returns>
    public static IEnumerable<string> GetWubiCode(string text, int length = 20)
    {
        text = HandlingText(text, length);
        if (!string.IsNullOrEmpty(text))
        {
            // 默认第一位首码时的内容并返回
            var def = text
                .ToCharArray()
                .Select(ch => _dicHanzi.ContainsKey(ch) ? _dicHanzi[ch].wubi[0] : ch);
 
            yield return new string(def.ToArray());
 
            // 记录迭代到指定位置时还未返回的所有可能
            List<List<char>> list = new List<List<char>> { new List<char>() };
 
            // 循环字符串的所有字符
            for (int i = 0; i < text.Length; i++)
            {
                if (_dicHanzi.ContainsKey(text[i]))
                {
                    // 当前字符存在首码
                    char[] wubi = _dicHanzi[text[i]].wubi;
                    if (wubi.Length > 1)
                    {
                        // 1. 存在多个首码，需要将每种可能的结果返回，并且更新所有组合的可能性
                        // 获取当前位置之后的默认字符，用于返回
                        IEnumerable<char> last = def.Take(i + 1);
 
                        // 更新截止到当前字符之前的所有可能
                        List<List<char>> update = new List<List<char>>();
 
                        // 循环截止到当前字符之前的所有可能
                        for (int j = 0; j < list.Count; j++)
                        {
                            // 循环当前字符的所有首码
                            for (int k = 0; k < wubi.Length; k++)
                            {
                                var current = new List<char>(list[j]) { wubi[k] };
 
                                // 将截至到当前位置的所有默认可能返回
                                if (k > 0)
                                {
                                    var result = new List<char>(current);
                                    result.AddRange(last);
                                    yield return new string(result.ToArray());
                                }
 
                                update.Add(current);
                            }
                        }
 
                        // 可能性增加，需要更新
                        list = update;
                    }
                    else
                    {
                        // 2. 只存在一个首码，将当前字符的首码添加到内容中
                        list.ForEach(l => l.Add(_dicHanzi[text[i]].wubi[0]));
                    }
                }
                else
                {
                    // 当前字符不存在五笔首码，则将当前字符添加到内容中
                    list.ForEach(l => l.Add(text[i]));
                }
            }
        }
    }
 
    /// <summary>
    /// 获取一段中文的拼音首码
    /// </summary>
    /// <param name="text">中文内容</param>
    /// <param name="length">期望返回拼音首码的最大长度，默认 20</param>
    /// <returns>处理后的拼音首码</returns>
    public static IEnumerable<string> GetPinyinCode(string text, int length = 20)
    {
        text = HandlingText(text, length);
        if (!string.IsNullOrEmpty(text))
        {
            // 默认第一位首码时的内容并返回
            var def = text
                .ToCharArray()
                .Select(ch => _dicHanzi.ContainsKey(ch) ? _dicHanzi[ch].pinyin[0] : ch);
 
            yield return new string(def.ToArray());
 
            // 记录迭代到指定位置时还未返回的所有可能
            List<List<char>> list = new List<List<char>> { new List<char>() };
 
            // 循环字符串的所有字符
            for (int i = 0; i < text.Length; i++)
            {
                if (_dicHanzi.ContainsKey(text[i]))
                {
                    // 当前字符存在首码
                    char[] pinyin = _dicHanzi[text[i]].pinyin;
                    if (pinyin.Length > 1)
                    {
                        // 1. 存在多个首码，需要将每种可能的结果返回，并且更新所有组合的可能性
                        // 获取当前位置之后的默认字符，用于返回
                        IEnumerable<char> last = def.Skip(i + 1);
 
                        // 更新截止到当前字符之前的所有可能
                        List<List<char>> update = new List<List<char>>();
 
                        // 循环截止到当前字符之前的所有可能
                        for (int j = 0; j < list.Count; j++)
                        {
                            // 循环当前字符的所有首码
                            for (int k = 0; k < pinyin.Length; k++)
                            {
                                var current = new List<char>(list[j]) { pinyin[k] };
 
                                // 将截至到当前位置的所有默认可能返回
                                if (k > 0)
                                {
                                    var result = new List<char>(current);
                                    result.AddRange(last);
                                    yield return new string(result.ToArray());
                                }
 
                                update.Add(current);
                            }
                        }
 
                        // 可能性增加，需要更新
                        list = update;
                    }
                    else
                    {
                        // 2. 只存在一个首码，将当前字符的首码添加到内容中
                        list.ForEach(l => l.Add(_dicHanzi[text[i]].pinyin[0]));
                    }
                }
                else
                {
                    // 当前字符不存在拼音首码，则将当前字符添加到内容中
                    list.ForEach(l => l.Add(text[i]));
                }
            }
        }
    }
 
    // 特殊字符字典
    private static Dictionary<char, char> _dicChar = new Dictionary<char, char>
        {
            ['Ａ'] = 'A',
            ['Ｂ'] = 'B',
            ['Ｃ'] = 'C',
            ['Ｄ'] = 'D',
            ['Ｅ'] = 'E',
            ['Ｆ'] = 'F',
            ['Ｇ'] = 'G',
            ['Ｈ'] = 'H',
            ['Ｉ'] = 'I',
            ['Ｊ'] = 'J',
            ['Ｋ'] = 'K',
            ['Ｌ'] = 'L',
            ['Ｍ'] = 'M',
            ['Ｎ'] = 'N',
            ['Ｏ'] = 'O',
            ['Ｐ'] = 'P',
            ['Ｑ'] = 'Q',
            ['Ｒ'] = 'R',
            ['Ｓ'] = 'S',
            ['Ｔ'] = 'T',
            ['Ｕ'] = 'U',
            ['Ｖ'] = 'V',
            ['Ｗ'] = 'W',
            ['Ｘ'] = 'X',
            ['Ｙ'] = 'Y',
            ['Ｚ'] = 'Z',
            ['ａ'] = 'a',
            ['ｂ'] = 'b',
            ['ｃ'] = 'c',
            ['ｄ'] = 'd',
            ['ｅ'] = 'e',
            ['ｆ'] = 'f',
            ['ｇ'] = 'g',
            ['ｈ'] = 'h',
            ['ｉ'] = 'i',
            ['ｊ'] = 'j',
            ['ｋ'] = 'k',
            ['ｌ'] = 'l',
            ['ｍ'] = 'm',
            ['ｎ'] = 'n',
            ['ｏ'] = 'o',
            ['ｐ'] = 'p',
            ['ｑ'] = 'q',
            ['ｒ'] = 'r',
            ['ｓ'] = 's',
            ['ｔ'] = 't',
            ['ｕ'] = 'u',
            ['ｖ'] = 'v',
            ['ｗ'] = 'w',
            ['ｘ'] = 'x',
            ['ｙ'] = 'y',
            ['ｚ'] = 'z',
            ['０'] = '0',
            ['１'] = '1',
            ['２'] = '2',
            ['３'] = '3',
            ['４'] = '4',
            ['５'] = '5',
            ['６'] = '6',
            ['７'] = '7',
            ['８'] = '8',
            ['９'] = '9',
        };
    // 用于替换内容，保留数字、小写字母、大写字母、基本汉字、〇、全角数字、全角小写字母、全角大写字母
    private static readonly Regex _regex = new Regex(@"[^0-9A-Za-z\u4E00-\u9FA5\u3007０-９ａ-ｚＡ-Ｚ]");
    private static string HandlingText(string text, int length = 20)
    {
        if (string.IsNullOrWhiteSpace(text)) return "";
 
        // 将非数字字母汉字等移除
        text = _regex.Replace(text, "");
 
        List<char> content = new List<char>();
        // 正则会移除高位字符，这里进行迭代已经不会出现高位字符被拆成两个特殊字符的情况
        foreach (char ch in text)
        {
            // 将特殊字符替换，例如全角字符替换为半角
            if (_dicChar.ContainsKey(ch))
            {
                content.Add(_dicChar[ch]);
            }
            else
            {
                content.Add(ch);
            }
 
            if (content.Count >= length) break;
        }
 
        return new string(content.ToArray()).ToUpper();
    }
}