过滤内容问题（内容库比较大（2000短语左右）），对效率较高（具体看内容）

Question

我是用indexof判断的  太慢
后来用正则判断 更慢
现在平均每秒150个
速度要提升到每秒10000个左右才可以
（前几天提问了个过滤号码问题 解决了 ）

Answer 1

txwd0033() ( ):用正则判断的话，正则语句要写好效率也是很高的
同意

Answer 2

那正则怎么写快呢
string[] bwords = BadWords.Split('#');
int i,j;
string str;
StringBuilder sb = new StringBuilder();
for(i = 0; i< bwords.Length; i++)
{
str=bwords[i].ToString().Trim();
string regStr,toStr;
regStr=str;
Regex r=new Regex(regStr,RegexOptions.IgnoreCase | RegexOptions.Singleline| RegexOptions.Multiline);
Match m=r.Match(chkStr);
if(m.Success)
{
isOK = true;
}
sb.Remove(0,sb.Length);
}
return isOK;

Answer 3

RegexOptions.Multiline ==>RegexOptions.Compiled

Answer 4

加上RegexOptions.Compiled 是快了 但想对于indexof还是慢很多  不符合要求

Answer 5

看这个帖子viena(维也纳nn)最后的回复
http://community.csdn.net/Expert/topic/5383/5383234.xml?temp=.8008997对效率要求较高，把最后两行替换为
string sOut = Regex.Replace(sIn, pattern.ToString() , "", RegexOptions.Compiled);

Answer 6

用内存换效率为类增加静态成员
static Regex[] _Regs;
并且初始化
for(i = 0; i< bwords.Length; i++){
Regex r=new Regex(regStr,RegexOptions.IgnoreCase | RegexOptions.Singleline| RegexOptions.Compiled);
}调用时
foreach(Regex reg in _Regs){
  //在这儿工作,不用再实例化150个或1000个Regex
}

Answer 7

foreach
对foreach 试试

Answer 8

foreach也不快 速度几乎一样

Answer 9

今天无聊
自己测试了一下
如果只是要简单的过滤指定的词
还是string.replace最快;using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;namespace RASTest
{
    class Program
    {
        static void Main(string[] args)
        {
            DateTime start;
            int regLength = 2000;
            int strLength = 1000;            ReplaceString3 rs3 = ReplaceString3.Instance(regLength);
            string str3 = CreateString(strLength);
            start = DateTime.Now;
            str3 = rs3.Replace(str3);
            Console.WriteLine(((TimeSpan)(DateTime.Now - start)).ToString());
            ReplaceString rs=ReplaceString.Instance(regLength);
            string str1 = CreateString(strLength);
            start = DateTime.Now;
            str1 = rs.Replace(str1);
            Console.WriteLine(((TimeSpan)(DateTime.Now - start)).ToString());            ReplaceString2 rs2 = ReplaceString2.Instance(regLength);
            string str2 = CreateString(strLength);
            start = DateTime.Now;
            str2 = rs2.Replace(str2);
            Console.WriteLine(((TimeSpan)(DateTime.Now - start)).ToString());          
            
            Console.Read();
        } 
        public static string CreateString(int length){
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < length; i++) {
                sb.AppendFormat("\n{0}\n", i);
            }
            return sb.ToString();
        }
    }
   
    public class ReplaceString { 
        private static ReplaceString _Instance;
        private Regex[] _Regs;
        private ReplaceString(int length){
            _Regs = new Regex[length];
            for (int i = 0; i < _Regs.Length; i++) { 
                string pattern =String.Format(@"\n{0}\n",i.ToString());
                _Regs[i] = new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled);
            }
            _Instance = this;
        }        public static ReplaceString Instance(int length)
        {
                if (_Instance == null)
                {
                    _Instance = new ReplaceString(length);
                }
                return _Instance;
        }        public string Replace(string str) {
            foreach (Regex reg in _Regs) {
                str = reg.Replace(str, "\n...\n");
            }
            return str;
        }
    }    public class ReplaceString2{
        private static ReplaceString2 _Instance;
        private Regex _Reg;
        private ReplaceString2(int length){
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i <length; i++) { 
                sb.AppendFormat(@"\n{0}\n|",i.ToString());
            }
            string pattern = sb.ToString(0, sb.Length - 1);
            _Reg = new Regex(pattern,RegexOptions.IgnoreCase|RegexOptions.Compiled);
            _Instance = this;
        }        public static ReplaceString2 Instance(int length)
        {
                if (_Instance == null)
                {
                    _Instance = new ReplaceString2(length);
                }
                return _Instance;
            
        }        public string Replace(string str) {
            return _Reg.Replace(str, "\n...\n");
        }
    }    public class ReplaceString3 {
        private static ReplaceString3 _Instance;
        private string[] _Word;
        private ReplaceString3(int length) {
            _Word = new string[length];
            for (int i = 0; i < length; i++) {
                _Word[i] = String.Format("\n{0}\n",i);
            }
            _Instance = this;
        }        public static ReplaceString3 Instance(int length) {
            if (_Instance == null) {
                _Instance = new ReplaceString3(length);
            }
            return _Instance;
        }        public string Replace(string str) {
            foreach (string patt in _Word) {
                str = str.Replace(patt, "\n...\n");
            }
            return str;
        }
    }
}
====运行结果
00:00:00.1562500
00:00:06.7968750
00:00:14.7343750

Answer 10

我需要的是返回结果才可以 就是包含true

Answer 11

不管是怎么变换过滤词的长度和文本长度
都是string.replace表现最优
当然这也许和样本复杂度有关
但是我推荐直接使用string.replace

Answer 12

直接使用string.replace是不可以的 因为程序不允许 如果包含必须返回值才可行，因为要用

Answer 13

Replace:00:00:00.2303312
  Split:00:00:00.0200288

Answer 14

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;namespace WindowsApplication29
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        public static string CreateString(int length)
        {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < length; i++)
            {
                sb.AppendFormat("\n{0}\n", i);
            }
            return sb.ToString();
        }        private void button1_Click(object sender, EventArgs e)
        {
            DateTime start;
            start = DateTime.Now;            int regcount = 5000;
            int strLength = 1000;            string[] _Word;
            _Word = new string[regcount];
            for (int i = 0; i < regcount; i++)
            {
                _Word[i] = String.Format("\n{0}\n", i);
            }            string buff = CreateString(strLength);
            foreach (string patt in _Word)
            {
                buff = buff.Replace(patt, "\n...\n");
            }
            textBox1.Text="Replace:"+((TimeSpan)(DateTime.Now - start)).ToString();          
        }        private void button2_Click(object sender, EventArgs e)
        {
            DateTime start;
            start = DateTime.Now;            int regcount = 5000;
            int strLength = 1000;            string[] _Word;
            _Word = new string[regcount];
            for (int i = 0; i < regcount; i++)
            {
                _Word[i] = String.Format("\n{0}\n", i);
            }            string buff = CreateString(strLength);            /*
             foreach (string patt in _Word)
            {
                buff = buff.Replace(patt, "\n...\n");
            }
             */
            string[] _data = buff.Split(_Word, StringSplitOptions.None);
            StringBuilder sb = new StringBuilder();            if (_data.Length > 0)
                sb.Append(_data[0]);
            for (int i = 1; i < _data.Length; i++)
            {
                sb.Append("\n...\n");
                sb.Append(_data[i]);
            }            buff = sb.ToString();            textBox2.Text = "Split:" + ((TimeSpan)(DateTime.Now - start)).ToString(); 
        }
    }
}

Answer 15

regcount = 5000 越大 Split的 优势越明显
regcount <2000 两者 查不多
strLength  也有关

Answer 16

返回值 可以 通过 _data.Length 计算出来
 _data.Length-1 就是 替换了 多少处

Answer 17

至于返回值不是问题,是需要指示是否改变了字符串吗?只需要比较字符串前后是否相等即可
例子:(盗用了楼上的split方法)
public bool Replace(ref string str) {
            string returns = str;            string[] _data = str.Split(_Word, StringSplitOptions.None);
            StringBuilder sb = new StringBuilder();            if (_data.Length > 0)
                sb.Append(_data[0]);
            for (int i = 1; i < _data.Length; i++)
            {
                sb.Append("\n...\n");
                sb.Append(_data[i]);
            }            str = sb.ToString();            return returns != str;
        }

Answer 18

return returns != str;
 这样 不好 如果 是 长字符串 并且在 尾部 替换 同长度的 字符串 就耗资源
 
 我有 鸡蛋里挑骨头的 的习惯
 多多 包含

Answer 19

我用了 withcsharp() 的方法
过滤池里有2000个短语（2-6个字的短语） 过滤效率是每秒1400多个 速度太慢

Answer 20

恩  是快了不少
private void button1_Click(object sender, System.EventArgs e)
{
DateTime startTime = DateTime.Now;
int j = 0;
foreach(string s in al2)
{
if(s!=null)
{
if(this.isContentOKm(s))
{
j++;
}
}
} DateTime endTime = DateTime.Now;
System.TimeSpan   ts = endTime - startTime;
label1.Text = al2.Count+"个短句里包含"+j+"个非法词语\r\n";
label1.Text += "程序运行时间"+ts.ToString();
}
private  bool isContentOKm(string strContent)
{
bool isOK = false;

if (strContent != null)
{
for(int i=0;i<al.Count;i++)
{
string s = strContent.Replace(al[i].ToString(),"");
if(s.Length<strContent.Length)
{
isOK = true;
break;
}
}
}
return isOK;
}

Answer 21

简单的办法，把string分成10段，开10个线程，每个线程同时进行。
简单的办法，把string分成10段，开10个线程，每个线程同时进行。
简单的办法，把string分成10段，开10个线程，每个线程同时进行。
简单的办法，把string分成10段，开10个线程，每个线程同时进行。
简单的办法，把string分成10段，开10个线程，每个线程同时进行。
简单的办法，把string分成10段，开10个线程，每个线程同时进行。
简单的办法，把string分成10段，开10个线程，每个线程同时进行。
简单的办法，把string分成10段，开10个线程，每个线程同时进行。
简单的办法，把string分成10段，开10个线程，每个线程同时进行。
简单的办法，把string分成10段，开10个线程，每个线程同时进行。
简单的办法，把string分成10段，开10个线程，每个线程同时进行。
简单的办法，把string分成10段，开10个线程，每个线程同时进行。
简单的办法，把string分成10段，开10个线程，每个线程同时进行。
简单的办法，把string分成10段，开10个线程，每个线程同时进行。
简单的办法，把string分成10段，开10个线程，每个线程同时进行。
简单的办法，把string分成10段，开10个线程，每个线程同时进行。
简单的办法，把string分成10段，开10个线程，每个线程同时进行。

Answer 22

如果 只判断 有没有非法词语
可以去掉
            StringBuilder sb = new StringBuilder();            if (_data.Length > 0)
                sb.Append(_data[0]);
            for (int i = 1; i < _data.Length; i++)
            {
                sb.Append("\n...\n");
                sb.Append(_data[i]);
            }            buff = sb.ToString();

Answer 23

如果 现在 cpu 已经很高的 话 分线程 负担更重
而且 string分成10段 还要 考虑 有没有 那个短语 会被 分在两段 中 造成 误判。

Answer 24

把短语建立索引，便于查找，比如按拼音建立索引string Text="待过滤的文本";
for(int i=0;i<Text.Length;i++)
{
     如果Text[i]在短语库有短语的第一个字符与之相同 （按照索引快速查找）
     {
          判断Text在i出是否与短语库中的短语相同；
          如果相同 则找到了一个
      }
}

Answer 25

//假设输入的全是E文 按单词的首字母索引
//首先从数据库中或其他的什么媒体上读取所有的单词（短语）
//将这些单词按字母顺序排序 ->Words
//建立索引 int [,]Indexs = new int[26,2];
//将排好序的单词序列 26字母中每个字母出现在序列中的第一个位置和最后一个位置记录到Indexs相应的位置处
//循环Text
//      根据Text[i]的值定位Indexs的位置x，在Words[Indexs[x,0]]到Words[Indexs[x,1]]范围内看是否能找到Text[i]处的单词