C#字符串查找的优化

这两天改变了关键词库，要求将以前的旧资料包括新闻问答商机等的所有数据的关键词重新匹配生成一遍。

先让老喻做了个功能页出来，生成12条数据大概要30、40秒左右，感觉太慢了，就自己再想想有没有更优的方法。

基本情况是：

总数据大概有300多万，分布在10来个表里。

关键词库约有4万。

 

关键词库已经存在Cache里了，对性能没什么影响。

 

1.         public string[] KeyWordStrs = null;
3.         /// <summary>
4.         /// 获取缓存中的关键词组
5.         /// </summary>
6.         private void GetKeyWordStrs()
7.         {
8.             if (KeyWordStrs != null) { return; }
10.             if (HttpContext.Current.Cache["keywords"] == null)
11.             {
12.                 string sql = "Select [Name] From [KeyWords]";
13.                 DataSet dSet1 = GetDataSet(sql);
14.                 if (dSet1 == null || dSet1.Tables.Count <= 0) { return; }
15.                 string[] str = new string[dSet1.Tables[0].Rows.Count];
16.                 for (int i = 0; i < dSet1.Tables[0].Rows.Count; i++)
17.                 {
18.                     str[i] = dSet1.Tables[0].Rows[i][0].ToString();
19.                 }
20.                 dSet1.Dispose();
21.                 dSet1 = null;
22.                 HttpContext.Current.Cache.Insert("keywords",str);
23.                 return;
24.             }
26.             KeyWordStrs = (string[])HttpContext.Current.Cache["keywords"];
27.         }

反复测试，发现最浪费时间的就是每次的4万次匹配。

一开始是用IndexOf方法来验证，从数据表里将记录读出来，每次1000条左右，循环中再从4万个词库里判断是否大于0,组合成关键词组：

1.     /// <summary>
2.     /// 返回关键词字符串,不超过100个字符
3.     /// </summary>
4.     /// <param name="title">标题</param>
5.     /// <param name="content">内容</param>
6.     /// <returns>返回关键词字符串</returns>
7.     public string GetKeyWords(string title, string content)
8.     {
9.         GetKeyWordStrs();
10.         if (KeyWordStrs == null) { return ""; }
12.         if (content.Length < 2 && title.Length < 2) { return ""; }
14.         string keywords = string.Empty;
15.         //如果标题长度小于2,只匹配内容
16.         if (title.Length < 2)
17.         {
18.             foreach (string s in KeyWordStrs)
19.             {
20.                 if (content.IndexOf(s) >= 0)
21.                 {
22.                     keywords = keywords + "," + s;
23.                 }
24.                 //如果长度大于99则中止循环
25.                 if (keywords.Length > 99) { break; }
26.             }
27.         }
28.         else
29.         {
30.             foreach (string s in KeyWordStrs)
31.             {
32.                 //如果标题已经匹配
33.                 if (title.IndexOf(s)>= 0)
34.                 {
35.                     keywords = keywords + "," + s;
36.                 }
37.                 //标题未能匹配时再按内容匹配
38.                 else if (content.IndexOf(s)>= 0)
39.                 {
40.                     keywords = keywords + "," + s;
41.                 }
42.                 //如果长度大于99则中止循环
43.                 if (keywords.Length > 99) { break; }
44.             }
45.         }
46.     }

随机取了1 2条数据，总费时34-40秒左右。

这种效果肯定不行，于是自己找了找字符串查找的相关优化方法，GOOGLE和BAIDU也没提到什么，想了一下用正则的试试看看，改了一下代码：

1.     /// <summary>
2.     /// 返回关键词字符串,不超过100个字符
3.     /// </summary>
4.     /// <param name="title">标题</param>
5.     /// <param name="content">内容</param>
6.     /// <returns>返回关键词字符串</returns>
7.     public string GetKeyWords(string title, string content)
8.     {
9.         GetKeyWordStrs();
10.         if (KeyWordStrs == null) { return ""; }
12.         if (content.Length < 2 && title.Length < 2) { return ""; }
14.         string keywords = string.Empty;
15.         Regex r;
16.         //如果标题长度小于2,只匹配内容
17.         if (title.Length < 2)
18.         {
19.             foreach (string s in KeyWordStrs)
20.             {
21.                 //先过滤特殊字符
22.                 r = new Regex(s.Replace(".", @"/.").Replace("(", "").Replace(")", ""));
23.                 if (r.IsMatch(content))
24.                 {
25.                     keywords = keywords + "," + s;
26.                 }
27.                 //如果长度大于99则中止循环
28.                 if (keywords.Length > 99) { break; }
29.             }
30.         }
31.         else
32.         {            
33.             foreach (string s in KeyWordStrs)
34.             {
35.                 //先过滤特殊字符
36.                 r = new Regex(s.Replace(".", @"/.").Replace("(", "").Replace(")", ""));
37.                 //如果标题已经匹配
38.                 if (r.IsMatch(title))
39.                 {
40.                     keywords = keywords + "," + s;
41.                 }
42.                 //标题未能匹配时再按内容匹配
43.                 else if (r.IsMatch(content))
44.                 {
45.                     keywords = keywords + "," + s;
46.                 }
47.                 //如果长度大于99则中止循环
48.                 if (keywords.Length > 99) { break; }
49.             }
50.         }
51.     }

有提高了，同样的12条数据花了12秒左右，有了明显的提升呢。

不知道还有没更快的方式呢？

乱找了一下，发现String有个Contains方法，试了一下，时间一下子就缩短到4左右，看来这个效率是最快的了。

1.     public string GetKeyWords(string title, string content)
2.     {
3.         GetKeyWordStrs();
4.         if (KeyWordStrs == null) { return ""; }
6.         if (content.Length < 2 && title.Length < 2) { return ""; }
8.         //如果标题长度小于2,只匹配内容
9.         if (title.Length < 2)
10.         {
11.             foreach (string s in KeyWordStrs)
12.             {
13.                 //如果标题已经匹配
14.                 if (title.Contains(s))
15.                 {
16.                     keywords = keywords + "," + s;
17.                 }
18.                 //标题未能匹配时再按内容匹配
19.                 else if (content.Contains(s))
20.                 {
21.                     keywords = keywords + "," + s;
22.                 }
23.                 //如果长度大于99则中止循环
24.                 if (keywords.Length > 99) { break; }
25.             }
26.         }
27.         else
28.         {            
29.             foreach (string s in KeyWordStrs)
30.             {
31.                 //如果标题已经匹配
32.                 if (title.Contains(s))
33.                 {
34.                     keywords = keywords + "," + s;
35.                 }
36.                 //标题未能匹配时再按内容匹配
37.                 else if (content.Contains(s))
38.                 {
39.                     keywords = keywords + "," + s;
40.                 }
41.                 //如果长度大于99则中止循环
42.                 if (keywords.Length > 99) { break; }
43.             }
44.         }
45.     }

 

不知道还没有更好的方式来处理呢？