郑德才博客

public class MatchHelper
{
    /// <summary>
    /// 正则匹配结果集中的第一个匹配项
    /// </summary>
    /// <param name="regularString">进行匹配的字符串集</param>
    /// <param name="regularExpressions">正则表达式规则</param>
    /// <param name="isSubScalar">isSubScalar默认值为 1 ，为 0 时匹配第一项不为空的项，为 1 时匹配第一项不为空的子项，该参数可以忽略。</param>
    /// <returns></returns>
    internal static string MatchScalar(string regularString, string regularExpressions, int isSubScalar = 1)
    {
        string returnVal = "";
        try
        {
            MatchCollection M = Regex.Matches(regularString, regularExpressions);
            foreach (Match m in M)
            {
                for (int i = isSubScalar; i < m.Groups.Count; i++)
                {
                    returnVal = m.Groups[i].Value;
                    if (returnVal == "")
                    {
                        continue;
                    }
                    else
                    {
                        return returnVal;
                    }
                }
            }
            return returnVal;
        }
        catch (Exception ee)
        { 
            return "";
        }
    }
    /// <summary>
    /// 根据正则表达式匹配出所有的符合条件的字符串。
    /// <para>结果将以 DataTable 类型返回。</para>
    /// </summary>
    /// <param name="regularString">待匹配的字符集合。</param>
    /// <param name="regularExpressions">正则表达式。</param>
    /// <param name="isSubDt">isSubDt默认值为 1 ，为 0 时匹配所有符合条件项，为 1 时匹配所有符合条件子项，该参数可以忽略。</param>
    /// <returns>DataTable</returns>
    internal static DataTable MatchDt(string regularString, string regularExpressions, int isSubDt = 1)
    {
        try
        {
            DataTable dt = new DataTable();
            MatchCollection M = Regex.Matches(regularString, regularExpressions);
            if (M.Count <= 0) return dt;
            foreach (Match m in M)
            {
                var dr = dt.NewRow();
                for (var i = isSubDt; i < m.Groups.Count; i++)
                {
                    if (dt.Columns.Count <= 0)
                    {
                        for (var k = isSubDt; k < m.Groups.Count; k++)
                        {//创建列名
                            dt.Columns.Add("匹配项" + (k + 1));
                        }
                    }
                    if (isSubDt == 1)
                        dr[i - 1] = m.Groups[i].Value;
                    else
                        dr[i] = m.Groups[i].Value;
                }
                dt.Rows.Add(dr);
            }
            return dt;
        }
        catch (Exception ee)
        { 
            return null;
        }
    }
    /// <summary>
    /// 根据正则表达式匹配出所有的符合条件的字符串。
    /// <para>结果将以 List 类型返回。</para>
    /// </summary>
    /// <param name="regularString">待匹配的字符集合。</param>
    /// <param name="regularExpressions">正则表达式规则。</param>
    /// <param name="isFilterRepetition">isFilterRepetition默认值为 1 ,表示过滤掉重复的项，为 0 时表示不过滤掉</param>
    /// <param name="isSubLists">isSubLists默认值为 1 ，为 0 时匹配所有符合条件项，为 1 时匹配所有符合条件子项，该参数可以忽略。</param>
    /// <param name="isContainEmptyValue">isContainEmptyValue默认值为 0 ，为 0 时过滤掉值为空的项，为 1 时包含值为空的项，该参数可以忽略。</param>
    /// <returns>List</returns>
    internal static List<string> MatchLists(string regularString, string regularExpressions, int isFilterRepetition = 1, int isSubLists = 1, int isContainEmptyValue = 0)
    {
        try
        {
            if (regularString == null) throw new ArgumentNullException("regularString");
            if (regularExpressions == null) throw new ArgumentNullException("regularExpressions");
            var list = new List<string>();
            MatchCollection M = Regex.Matches(regularString, regularExpressions);
            if (M.Count <= 0) return list;
            foreach (Match m in M)
            {
                for (var i = isSubLists; i < m.Groups.Count; i++)
                {
                    var val = m.Groups[i].Value;
                    if (isContainEmptyValue == 0)
                    {
                        if (val.Length <= 0) continue;
                    }
                    if (isFilterRepetition == 1)
                    {
                        if (!list.Contains(val))
                        {
                            list.Add(val);
                        }
                    }
                    else
                    {
                        list.Add(val);
                    }
                }
            }
            return list;
        }
        catch (Exception ee)
        { 
            return null;
        }
    }
}