C# 简陋版词汇过滤

最新推荐文章于 2021-05-18 18:14:39 发布
最新推荐文章于 2021-05-18 18:14:39 发布
阅读量202 收藏
点赞数
分类专栏： C# 文章标签： c# 过滤器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dear200892/article/details/116742715
版权

敏感词过滤的方法有很多，我这篇是简陋版！！

实力有限，只能简单的匹配出结果，无法保证效率问题！

参考网上的资料，涂涂改改写下了这个类。

一 基础类

 1.1 字符树

    /// <summary>
    /// 字符树
    /// </summary>
    public class CharacterTree
    {
        /// <summary>
        /// 字符
        /// </summary>
        public char Word { get; set; }
        /// <summary>
        /// 是否末尾
        /// </summary>
        public bool IsEnd { get; set; }
        /// <summary>
        /// 子节点
        /// </summary>
        public List<CharacterTree> Child { get; set; }

        /// <summary>
        /// 返回表示当前 System.Object 的 System.String
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            if (this.Word == '\u0000' || char.IsWhiteSpace(this.Word))
                return base.ToString();
            string msg = string.Format("单词:{0},是否末尾:{1}", this.Word.ToString(), this.IsEnd.ToString());
            if (this.Child != null && this.Child.Count > 0)
                msg = string.Format("{0},共{1}条分支", msg, this.Child.Count);
            return msg;
        }
    }

1.2 字符信息

    /// <summary>
    /// 字符信息
    /// </summary>
    public class Character
    {
        public Character(char word, int index)
        {
            this.Word = word;
            this.Index = index;
        }

        /// <summary>
        /// 字符
        /// </summary>
        public char Word { get; set; }

        /// <summary>
        /// 字符串中出现的索引
        /// </summary>
        public int Index { get; set; }

        /// <summary>
        /// 返回表示当前 System.Object 的 System.String
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            if (this.Word == '\u0000' || char.IsWhiteSpace(this.Word))
                return base.ToString();
            return string.Format("字符:{0},索引:{1}", this.Word.ToString(), this.Index.ToString());
        }
    }

二 词库的初始化

        假如词库中有两个字符串["我需要你","我拿走了"]，我设想词库就是一棵树，每一个字符串就是树上的树枝，字符就是上面的叶子。
        按照设想，我绘制了图一。

流程数
流程树

     字符“我”是这两个字符串数组的主干,字符“需”和字符“拿”则是分支。如果词库中再来了一些字符串，先在主干中匹配有没有，没有则创建新的主干，存在就在主干中查找分支。

三 KeySearch检索类

     提供了三个公开的方法：FindAll、Replace和IsContains，查找、替换和是否包含。其中查找的返回结果是文本中所有出现的词库词，没有对结果排除重复。

    /// <summary>
    /// 检索
    /// </summary>
    public class KeySearch
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="arry">词库</param>
        public KeySearch(List<string> arry)
        {
            if (arry == null || arry.Count == 0)
                throw new ArgumentNullException("arry", "词库不能为空");

            this.Tree = CreateTree(arry);
        }

        #region 属性

        /// <summary>
        /// 字符树
        /// </summary>
        public List<CharacterTree> Tree { get; private set; }

        /// <summary>
        /// 是否 忽视文本空白区域
        /// </summary>
        public bool IsIgnoreWhiteSpace { get; set; }

        private string _text = string.Empty;
        /// <summary>
        /// 字符串
        /// </summary>
        public string Text
        {
            get { return _text; }
            private set
            {
                if (string.IsNullOrWhiteSpace(value))
                    throw new ArgumentNullException("text", "文本值不能为空");
                if (this.IsIgnoreWhiteSpace)
                    _text = value.Replace(" ", "");
                else
                    _text = value;
            }
        }

        #endregion

        #region 字段

        /// <summary>
        /// 关键字索引字典[临时]
        /// <para>Key:字符信息</para>
        /// <para>Value:是否末位</para>
        /// </summary>
        private Dictionary<Character, bool> tempDic = new Dictionary<Character, bool>();

        #endregion

        /// <summary>
        /// 检索与文本匹配的所有元素
        /// </summary>
        /// <param name="text">文本</param>
        /// <returns></returns>
        public List<string> FindAll(string text)
        {
            List<string> list = new List<string>();
            List<CharacterTree> treeList = this.Tree;
            this.Text = text;

            for (int i = 0; i < this.Text.Length; i++)
            {
                CharacterTree tree = FindNode(treeList, this.Text[i], i);
                if (tree == null)
                {
                    if (tempDic.Count > 0)
                    {
                        list.Add(string.Concat<char>(tempDic.Keys.Select(a=>a.Word)));
                        tempDic.Clear();
                    }
                    treeList = this.Tree;
                }
                else
                {
                    if (tree.Child == null)
                    {
                        if (tempDic.Count > 0)
                        {
                            list.Add(string.Concat<char>(tempDic.Keys.Select(a => a.Word)));
                            tempDic.Clear();
                        }
                        treeList = this.Tree;
                    }
                    else
                    {
                        treeList = tree.Child;
                    }
                }                
            }
            return list.ToList();
        }

        /// <summary>
        /// 返回一个新字符串
        /// </summary>
        /// <param name="text">文本</param>
        /// <param name="newChar">替换符号</param>
        /// <returns></returns>
        public string Replace(string text, char newChar = '*')
        {
            List<CharacterTree> treeList = this.Tree;
            this.Text = text;

            StringBuilder newString = new StringBuilder(this.Text);           

            for (int i = 0; i < this.Text.Length; i++)
            {
                char charStr = this.Text[i];
                CharacterTree tree = FindNode(treeList, charStr, i);
                if (tree == null)
                {
                    foreach (var item in tempDic.Keys)
                    {
                        newString[item.Index] = newChar;
                    }
                    tempDic.Clear();
                    treeList = this.Tree;
                }
                else
                {
                    if (tree.Child == null)
                    {
                        foreach (var item in tempDic.Keys)
                        {
                            newString[item.Index] = newChar;
                        }
                        tempDic.Clear();
                        treeList = this.Tree;
                    }
                    else
                    {
                        treeList = tree.Child;                        
                    }
                }                
            }

            return newString.ToString();
        }

        /// <summary>
        /// 文本中是否含有词库内容
        /// </summary>
        /// <param name="text">文本</param>
        /// <returns></returns>
        public bool IsContains(string text)
        {
            List<CharacterTree> treeList = this.Tree;
            this.Text = text;            

            for (int i = 0; i < this.Text.Length; i++)
            {
                CharacterTree tree = FindNode(treeList, this.Text[i], i);
                if (tree == null)
                {
                    if (tempDic.Count > 0)
                    {
                        tempDic.Clear();
                        return true;
                    }
                    treeList = this.Tree;
                }
                else
                {
                    if (tree.Child == null || (this.Text.Length - i == 1))//考虑最后一位
                    {
                        if (tempDic.Count > 0)
                        {
                            tempDic.Clear();
                            return true;
                        }
                    }
                    else
                    {
                        treeList = tree.Child;
                    }
                }
            }
            return false;
        }

        /// <summary>
        /// 寻找节点
        /// </summary>
        /// <param name="treeList">分支数据</param>
        /// <param name="text">文本</param>
        /// <param name="index">当前索引</param>
        /// <returns></returns>
        private CharacterTree FindNode(List<CharacterTree> treeList, char charStr, int index)
        {
            CharacterTree tree = treeList.FirstOrDefault(a => a.Word == charStr);
            if (tree == null)
            {
                //排除情况：词库{"真的吗","你真好"},字符串："你真的吗",结果："真的吗"
                KeyValuePair<Character, bool> lastDic = (tempDic.Count > 0) ? tempDic.LastOrDefault() : default(KeyValuePair<Character, bool>);//字典中最后一个元素Key
                int lastDicIndex = lastDic.Key == null ? -1 : tempDic.LastOrDefault().Key.Index;

                if (index > 0 && index - lastDicIndex == 1 && !lastDic.Value)
                {
                    CharacterTree temp = this.Tree.FirstOrDefault(a => a.Word == this.Text[index - 1]);
                    tempDic.Clear();
                    if (temp != null)
                    {
                        CharacterTree tempChild = temp.Child.FirstOrDefault(a => a.Word == charStr);
                        if (tempChild != null)
                        {
                            tempDic.Add(new Character(temp.Word, index - 1), temp.IsEnd);//追加元素
                            tempDic.Add(new Character(tempChild.Word, index), tempChild.IsEnd);
                            return tempChild;
                        }
                    }
                }
            }
            else
            {
                tempDic.Add(new Character(tree.Word, index), tree.IsEnd);
            }
            return tree;
        }

        #region 初始化

        /// <summary>
        /// 创建字符树词库
        /// </summary>
        /// <param name="arry">词库</param>
        /// <returns></returns>
        private List<CharacterTree> CreateTree(List<string> arry)
        {            
            List<CharacterTree> tree = new List<CharacterTree>();

            foreach (var word in arry)
            {
                if (string.IsNullOrEmpty(word))
                    continue;
                char cha = word[0];
                //查找树中是否有分支
                CharacterTree node = tree.Find(a => a.Word == cha);
                if (node == null)
                    tree.Add(CreateRootTree(word));
                else
                    AppendChildTree(node, word);
            }

            return tree;
        }
        
        /// <summary>
        /// 创建分支主干
        /// </summary>
        /// <param name="word">单词</param>
        /// <returns></returns>
        private CharacterTree CreateRootTree(string word)
        {
            //根节点，此节点 值为空
            CharacterTree root = new CharacterTree();
            //移动 游标[中间变量]
            CharacterTree tree = root;

            for (int i = 0; i < word.Length; i++)
            {
                CharacterTree child = new CharacterTree() { Word = word[i], IsEnd = false, Child = null };
                tree.Child = new List<CharacterTree>() { child };
                //浅拷贝问题
                tree = child;
            }
            tree.IsEnd = true;

            return root.Child.First();
        }

        /// <summary>
        /// 追加分支节点
        /// </summary>
        /// <param name="childTree">树分支</param>
        /// <param name="word">单词</param>
        private void AppendChildTree(CharacterTree childTree, string word)
        {
            //移动 游标[中间变量]
            CharacterTree tree = childTree;

            for (int i = 1; i < word.Length; i++)
            {
                char cha = word[i];//已存在分支,从第二个开始
                List<CharacterTree> child = tree.Child;

                if (child == null)
                {
                    CharacterTree node = new CharacterTree() { Word = cha, IsEnd = false, Child = null };
                    tree.Child = new List<CharacterTree>() { node };
                    tree = node;
                }
                else
                {
                    CharacterTree node = child.Find(e => e.Word == cha);
                    if (node == null)
                    {
                        node = new CharacterTree() { Word = cha, IsEnd = false, Child = null };
                        child.Add(node);
                        tree = node;
                    }
                    else
                    {
                        tree = node;
                    }
                }
            }
            tree.IsEnd = true;
        }

        #endregion        
    }

四 运行结果

    如果词库中出现长短词汇，如“你真的”和“你真”，则返回“你真的”。

   如果文本中两个词汇相邻，词库“你真”和“真的吗”，文本“你真的吗”，被替换的文本“**的吗”。

   

运行结果
运行结果

 

Dear200892
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#敏感词过滤实现方法
09-03
主要介绍了C#敏感词过滤实现方法,涉及C#针对字符串操作的常用技巧,非常具有实用价值,需要的朋友可以参考下
C#语言常用英语单词
最新发布
qq_30725967的博客
12-02 664
C#常用英语单词
C#实现文本关键词过滤
书蠡的博客
08-08 3054
思路来自编译原理，当然跟编译原理的算法相比还错的很多， 上代码： /// /// 关键词标识方法 /// /// 待处理文本 /// 关键词，字符串，用符号separator隔开，可以改为直接传进来数组 /// 关键词加的buff 前 /// 关键词加的buff 后 /// 分
c#如何消除方法中的参数歧义
number1killer的博客
06-16 358
前几篇博文讲了C#的方法定义和调用；方法中的返回类型；方法中的参数传递；方法中使用可选参数的两种方法。C#方法的定义和调用实例（C#计算器实例）https://blog.csdn.net/number1killer/article/details/80540974 C#方法的返回类型实例解析（return类型和void类型https://blog.csdn.net/number1killer/a...
C#关键字快速过滤方法
绝凌峰
08-07 5519
本篇博客讲的方案，思路很简单，还是基于撒列，把每个关键词的第一个字作为key，把关键词作为value，把所有关键词撒列在一个Dictionary中，由于一个关键字可能对应多个关键词，所以value其实是一个关键词集合，通过遍历要过滤的内容，与关键字字典进行匹配，匹配的话就过滤掉，由于思路简单清晰，可能出现的BUG绝对很少，实现的代码才90多行，实现关键字过滤的功能代码才90多行，看到没有！而且效率
c语言敏感词屏蔽编程题,C#敏感词过滤实现方法
weixin_39640573的博客
05-18 842
本文实例讲述了C#敏感词过滤实现方法。分享给大家供大家参考。具体如下：这两天突然想到了敏感词过滤 就结合网上找到的资料自己写了一个，脏字数量700+(效率不是很高 测试在110多KB的情况下比replace快 3-4倍)测试结果图 单位:秒代码如下：System.Text.StringBuilder sb = new System.Text.StringBuilder(text.Length);s...
如何在列表、字典和集合中根据条件筛选数据
RookieFCB的专栏
07-23 628
实际案例在实际开发过程中，常常遇到如下几种情况： 过滤掉列表[3, 9, -1, 10, 20, -2, …]中的负数； 筛选出字典{‘Jack’:79, ‘Jim’:88, ‘Lucy’:92, …}中值高于90的键值对； 筛选出集合{77, 89, 32, 20, …}中能被3整除的元素。 故应学会在列表、字典和集合中根据条件筛选数据。
如何在列表，字典，集合中根据条件筛选数据？
走向未来
05-07 485
如何在列表，字典，集合中根据条件筛选数据？ （1）过滤掉列表[3,9,-1,10,20,-2]中的负数； （2）筛出字典{‘lili’:70, ‘tim’:88, ‘maggie’:99}中值大于90的项； （3）筛出集合{66,23,32,56}中能被3整除的元素； 解决方案： （1）列表 方法1：列表解析 [x for x in data if x>=0] 方法2：filter函数 fi...
【C#】敏感词过滤校验
萧然
01-04 2072
敏感词过滤的方法有很多，如何能更快速更大范围的匹配敏感词？ 敏感词库小的情况，用正则、字符串匹配即可实现，还可以按照首字母对敏感词分组以提高效率。 当词库比较大时，就需要考虑效率问题了··· 找了很多实现方法，感觉不是很适合现在的需求，于是自己尝试实现了一下，用的也是DFA算法。 参考：C#敏感词过滤算法实现、Java实现敏感词过滤 1. 创建敏感词库 1.1 收集敏感词 1.2...
C# 敏感字过滤实例 内含敏感字字典两个（字或词都可过滤）
01-15
C#敏感字过滤源码，里面有两个敏感词过滤字典，源码是winform程序的，下载了就可以进行测试，也可以自己在敏感字字典内加入自己需要过滤的内容。
C#实现过滤sql特殊字符的方法集合
09-03
主要介绍了C#实现过滤sql特殊字符的方法,以实例形式分析总结了C#针对SQL危险字符的几种常用的过滤技巧,非常具有实用价值,需要的朋友可以参考下
C#实现简单过滤非法字符实例
09-03
主要介绍了C#实现简单过滤非法字符的方法,涉及C#针对字符串遍历与判断的相关技巧,非常简单实用,需要的朋友可以参考下
C# MVC 过滤器防止SQL注入
09-15
C# MVC 过滤器防止SQL注入
C#正则过滤HTML标签并保留指定标签的方法
08-30
主要介绍了C#正则过滤HTML标签并保留指定标签的方法,涉及C#针对页面HTML元素正则匹配与替换相关操作技巧,需要的朋友可以参考下
C# 获取List[]数组中获取某个类型的集合数据
热门推荐
Dear200892的博客
07-22 1万+
场景假设：请结合自身情况修改！ 假设有两个集合，集合类型分别是【PhysicalResult】和【PhysicalSummary】 IEnumerable<PhysicalResult> results = Current.Where(resultfilter).OrderBy(a =>a.CompositeItem.Id).ToList(); IEnumerable&lt...
WPF DataGrid实现多选、反选和不选
Dear200892的博客
09-17 4044
本篇文章数据采自https://mp.csdn.net/postedit/78849632，本篇就不在重复了。 WPF 要实现DataGrid checkbox全选和反选，方法有几种： 方法一：更改XAML代码 <Window.Resources> <local:ImagesConverter x:Key="converter"/> <...
C# 计算某个函数的执行时间
Dear200892的博客
08-28 2602
Stopwatch的命名空间是using System.Diagnostics; Stopwatch的属性和方法如下： // // 摘要: // 提供一组方法和属性，可用于准确地测量运行时间。 若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 public class Stopwatch { ...
C# 合并两个不同类型集合数据
Dear200892的博客
09-30 2264
别名：使用lambda表达式来实现Left Join 先把两个不同的类数据摆上。 public class User { /// <summary> /// 用户编号 /// </summary> public int User_Id { get; set; } /// &...
c# 数组 用lambda过滤
05-24
在 C# 中，可以使用 Lambda 表达式和 LINQ 查询来过滤数组。以下是一个示例： ```csharp int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; // 使用 Lambda 表达式过滤数组 var filteredNumbers = numbers.Where(n => n % 2 == 0); foreach (var number in filteredNumbers) { Console.WriteLine(number); } ``` 在上面的代码中，我们定义了一个整数数组 `numbers`，然后使用 Lambda 表达式过滤出其中的偶数。Lambda 表达式 `(n => n % 2 == 0)` 表示如果一个数除以 2 的余数为 0，则认为它是一个偶数。 输出结果为： ``` 2 4 6 8 10 ``` 除了 Lambda 表达式外，我们也可以使用 LINQ 查询来过滤数组，如下所示： ```csharp int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; // 使用 LINQ 查询过滤数组 var filteredNumbers = from n in numbers where n % 2 == 0 select n; foreach (var number in filteredNumbers) { Console.WriteLine(number); } ``` 这段代码与上面的 Lambda 表达式示例代码实现的功能相同，只是使用了不同的语法。输出结果也相同。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值