HtmlToText c#

最新推荐文章于 2024-06-21 09:44:32 发布
最新推荐文章于 2024-06-21 09:44:32 发布
阅读量226 收藏
点赞数
文章标签： c#

原页面：http://www.oschina.net/code/snippet_54100_3800
www.chilkatsoft.com/refdoc/cshtmltotextref.html

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;

namespace Olympic
{
    /// <summary>
    /// Converts HTML to plain text.
    /// </summary>
    class HtmlToText
    {
        // Static data tables
        protected static Dictionary<string, string> _tags;
        protected static HashSet<string> _ignoreTags;

        // Instance variables
        protected TextBuilder _text;
        protected string _html;
        protected int _pos;

        // Static constructor (one time only)
        static HtmlToText()
        {
            _tags = new Dictionary<string, string>();
            _tags.Add("address", "\n");
            _tags.Add("blockquote", "\n");
            _tags.Add("div", "\n");
            _tags.Add("dl", "\n");
            _tags.Add("fieldset", "\n");
            _tags.Add("form", "\n");
            _tags.Add("h1", "\n");
            _tags.Add("/h1", "\n");
            _tags.Add("h2", "\n");
            _tags.Add("/h2", "\n");
            _tags.Add("h3", "\n");
            _tags.Add("/h3", "\n");
            _tags.Add("h4", "\n");
            _tags.Add("/h4", "\n");
            _tags.Add("h5", "\n");
            _tags.Add("/h5", "\n");
            _tags.Add("h6", "\n");
            _tags.Add("/h6", "\n");
            _tags.Add("p", "\n");
            _tags.Add("/p", "\n");
            _tags.Add("table", "\n");
            _tags.Add("/table", "\n");
            _tags.Add("ul", "\n");
            _tags.Add("/ul", "\n");
            _tags.Add("ol", "\n");
            _tags.Add("/ol", "\n");
            _tags.Add("/li", "\n");
            _tags.Add("br", "\n");
            _tags.Add("/td", "\t");
            _tags.Add("/tr", "\n");
            _tags.Add("/pre", "\n");

            _ignoreTags = new HashSet<string>();
            _ignoreTags.Add("script");
            _ignoreTags.Add("noscript");
            _ignoreTags.Add("style");
            _ignoreTags.Add("object");
        }

        /// <summary>
        /// Converts the given HTML to plain text and returns the result.
        /// </summary>
        /// <param name="html">HTML to be converted</param>
        /// <returns>Resulting plain text</returns>
        public string Convert(string html)
        {
            // Initialize state variables
            _text = new TextBuilder();
            _html = html;
            _pos = 0;

            // Process input
            while (!EndOfText)
            {
                if (Peek() == '<')
                {
                    // HTML tag
                    bool selfClosing;
                    string tag = ParseTag(out selfClosing);

                    // Handle special tag cases
                    if (tag == "body")
                    {
                        // Discard content before <body>
                        _text.Clear();
                    }
                    else if (tag == "/body")
                    {
                        // Discard content after </body>
                        _pos = _html.Length;
                    }
                    else if (tag == "pre")
                    {
                        // Enter preformatted mode
                        _text.Preformatted = true;
                        EatWhitespaceToNextLine();
                    }
                    else if (tag == "/pre")
                    {
                        // Exit preformatted mode
                        _text.Preformatted = false;
                    }

                    string value;
                    if (_tags.TryGetValue(tag, out value))
                        _text.Write(value);

                    if (_ignoreTags.Contains(tag))
                        EatInnerContent(tag);
                }
                else if (Char.IsWhiteSpace(Peek()))
                {
                    // Whitespace (treat all as space)
                    _text.Write(_text.Preformatted ? Peek() : ' ');
                    MoveAhead();
                }
                else
                {
                    // Other text
                    _text.Write(Peek());
                    MoveAhead();
                }
            }
            // Return result
            return HttpUtility.HtmlDecode(_text.ToString());
        }

        // Eats all characters that are part of the current tag
        // and returns information about that tag
        protected string ParseTag(out bool selfClosing)
        {
            string tag = String.Empty;
            selfClosing = false;

            if (Peek() == '<')
            {
                MoveAhead();

                // Parse tag name
                EatWhitespace();
                int start = _pos;
                if (Peek() == '/')
                    MoveAhead();
                while (!EndOfText && !Char.IsWhiteSpace(Peek()) &&
                    Peek() != '/' && Peek() != '>')
                    MoveAhead();
                tag = _html.Substring(start, _pos - start).ToLower();

                // Parse rest of tag
                while (!EndOfText && Peek() != '>')
                {
                    if (Peek() == '"' || Peek() == '\'')
                        EatQuotedValue();
                    else
                    {
                        if (Peek() == '/')
                            selfClosing = true;
                        MoveAhead();
                    }
                }
                MoveAhead();
            }
            return tag;
        }

        // Consumes inner content from the current tag
        protected void EatInnerContent(string tag)
        {
            string endTag = "/" + tag;

            while (!EndOfText)
            {
                if (Peek() == '<')
                {
                    // Consume a tag
                    bool selfClosing;
                    if (ParseTag(out selfClosing) == endTag)
                        return;
                    // Use recursion to consume nested tags
                    if (!selfClosing && !tag.StartsWith("/"))
                        EatInnerContent(tag);
                }
                else MoveAhead();
            }
        }

        // Returns true if the current position is at the end of
        // the string
        protected bool EndOfText
        {
            get { return (_pos >= _html.Length); }
        }

        // Safely returns the character at the current position
        protected char Peek()
        {
            return (_pos < _html.Length) ? _html[_pos] : (char)0;
        }

        // Safely advances to current position to the next character
        protected void MoveAhead()
        {
            _pos = Math.Min(_pos + 1, _html.Length);
        }

        // Moves the current position to the next non-whitespace
        // character.
        protected void EatWhitespace()
        {
            while (Char.IsWhiteSpace(Peek()))
                MoveAhead();
        }

        // Moves the current position to the next non-whitespace
        // character or the start of the next line, whichever
        // comes first
        protected void EatWhitespaceToNextLine()
        {
            while (Char.IsWhiteSpace(Peek()))
            {
                char c = Peek();
                MoveAhead();
                if (c == '\n')
                    break;
            }
        }

        // Moves the current position past a quoted value
        protected void EatQuotedValue()
        {
            char c = Peek();
            if (c == '"' || c == '\'')
            {
                // Opening quote
                MoveAhead();
                // Find end of value
                int start = _pos;
                _pos = _html.IndexOfAny(new char[] { c, '\r', '\n' }, _pos);
                if (_pos < 0)
                    _pos = _html.Length;
                else
                    MoveAhead();    // Closing quote
            }
        }

        /// <summary>
        /// A StringBuilder class that helps eliminate excess whitespace.
        /// </summary>
        protected class TextBuilder
        {
            private StringBuilder _text;
            private StringBuilder _currLine;
            private int _emptyLines;
            private bool _preformatted;

            // Construction
            public TextBuilder()
            {
                _text = new StringBuilder();
                _currLine = new StringBuilder();
                _emptyLines = 0;
                _preformatted = false;
            }

            /// <summary>
            /// Normally, extra whitespace characters are discarded.
            /// If this property is set to true, they are passed
            /// through unchanged.
            /// </summary>
            public bool Preformatted
            {
                get
                {
                    return _preformatted;
                }
                set
                {
                    if (value)
                    {
                        // Clear line buffer if changing to
                        // preformatted mode
                        if (_currLine.Length > 0)
                            FlushCurrLine();
                        _emptyLines = 0;
                    }
                    _preformatted = value;
                }
            }

            /// <summary>
            /// Clears all current text.
            /// </summary>
            public void Clear()
            {
                _text.Length = 0;
                _currLine.Length = 0;
                _emptyLines = 0;
            }

            /// <summary>
            /// Writes the given string to the output buffer.
            /// </summary>
            /// <param name="s"></param>
            public void Write(string s)
            {
                foreach (char c in s)
                    Write(c);
            }

            /// <summary>
            /// Writes the given character to the output buffer.
            /// </summary>
            /// <param name="c">Character to write</param>
            public void Write(char c)
            {
                if (_preformatted)
                {
                    // Write preformatted character
                    _text.Append(c);
                }
                else
                {
                    if (c == '\r')
                    {
                        // Ignore carriage returns. We'll process
                        // '\n' if it comes next
                    }
                    else if (c == '\n')
                    {
                        // Flush current line
                        FlushCurrLine();
                    }
                    else if (Char.IsWhiteSpace(c))
                    {
                        // Write single space character
                        int len = _currLine.Length;
                        if (len == 0 || !Char.IsWhiteSpace(_currLine[len - 1]))
                            _currLine.Append(' ');
                    }
                    else
                    {
                        // Add character to current line
                        _currLine.Append(c);
                    }
                }
            }

            // Appends the current line to output buffer
            protected void FlushCurrLine()
            {
                // Get current line
                string line = _currLine.ToString().Trim();

                // Determine if line contains non-space characters
                string tmp = line.Replace("&nbsp;", String.Empty);
                if (tmp.Length == 0)
                {
                    // An empty line
                    _emptyLines++;
                    if (_emptyLines < 2 && _text.Length > 0)
                        _text.AppendLine(line);
                }
                else
                {
                    // A non-empty line
                    _emptyLines = 0;
                    _text.AppendLine(line);
                }

                // Reset current line
                _currLine.Length = 0;
            }

            /// <summary>
            /// Returns the current output as a string.
            /// </summary>
            public override string ToString()
            {
                if (_currLine.Length > 0)
                    FlushCurrLine();
                return _text.ToString();
            }
        }
    }
}
weixin_33725722
关注
C#实现将HTML转换成纯文本的方法
09-03
主要介绍了C#实现将HTML转换成纯文本的方法,基于自定义类实现文本转换功能,具有一定参考借鉴价值,需要的朋友可以参考下
C#操作摄像头
02-17
在IT行业中，C#是一种广泛使用的编程语言，尤其在Windows应用程序开发中占据着重要的地位。本文将深入探讨如何使用C#来操作摄像头，基于提供的标题和描述，我们可以了解到这是一个关于利用C#进行摄像头编程的实际...
C# Html to Text
weixin_34128839的博客
06-24 156
为什么80%的码农都做不了架构师？>>> ...
html to text,HtmlToText C# Reference Documentation
weixin_39986178的博客
06-27 275
HtmlToText C# Reference DocumentationHtmlToTextCurrent Version: 9.5.0.87HTML to plain-text conversion component. The internal conversion process is much more sophisticated than can be accomplished wi...
html to txt
huzipiaoyiba的专栏
03-28 284
import java.io.BufferedReader;import java.io.FileInputStream;import java.io.InputStreamReader;import java.util.regex.Matcher;import java.util.regex.Pattern;   public class HtmltoText { public stati...
html to text,htmltotext · PyPI
weixin_33279929的博客
06-27 299
This package was written for a search engine, to allow it to extract thetextual content and metadata from HTML pages. It tries to cope withinvalid markup and incorrectly specified character sets, and...
html to text,HTMLAsText: Convert HTML to text (Freeware)
weixin_31180441的博客
06-27 277
HTMLAsText v1.11 - HTML to text freeware converterCopyright (c) 2004 - 2009 Nir SoferSee AlsoSearch for other utilities in NirSoftDescriptionHTMLAsText utility converts HTML documents to simple text f...
C#高性能大容量SOCKET并发完成端口例子（有C#客户端）完整实例源码
06-08
例子主要包括SocketAsyncEventArgs通讯封装、服务端实现日志查看、SCOKET列表、上传、下载、远程文件流、吞吐量协议，...服务端用C#编写，并使用log4net作为日志模块； 同时支持65536个连接，网络吞吐量可以达到400M。
C#自定义控件库
01-22
在.NET框架中，C#是一种常用的编程语言，用于开发各种应用程序，包括Windows桌面应用。"C#自定义控件库"是指使用C#语言编写的、由开发者自定义的控件集合，这些控件可以扩展.NET Framework的标准控件集，为用户提供...
C#常用类库(100多个)
12-09
在.NET框架中，C#语言提供了丰富的类库，使得开发者能够高效地进行各种操作。"C#常用类库(100多个)"这个资源包涵盖了众多实用的编程领域，包括文件处理、网络通信、HTTP交互、多线程、UI控件、Office文档操作、输入/...
C#基类整理
10-12
C#是一种广泛应用于桌面应用、Web开发、游戏开发和移动应用等领域的面向对象的编程语言。C#基类是其核心部分，提供了丰富的类库，让开发者能够快速构建功能强大的应用程序。以下是对标题和描述中提及的一些关键知识...
C#---HTML 转文本及HTML内容提取 .
weixin_33725270的博客
05-31 185
//1、HTML直接转文本 //使用方法HtmlToText convert = new HtmlToText();textBox2.Text = convert.Convert(textBox1.Text); //代码/// &lt;summary&gt;/// Converts HTML to plain text./// &lt;/summary&gt;class HtmlToText{...
实现html转文本
HouYing
05-07 1717
htmlToText(html) { try { return html.replace(/<(style|script|iframe)[^>]*?>[\s\S]+?<\/\1\s*>/gi, '').replace(/<[^>]+?>/g, '').replace(/\s+/g, ' ').replace(/ /g, ' ') .replace(/>/g, ' '); } catch...
C#---HTML 转文本及HTML内容提取
热门推荐
cjh200102的专栏
09-27 1万+
//1、HTML直接转文本 //使用方法 HtmlToText convert = new HtmlToText(); textBox2.Text = convert.Convert(textBox1.Text); //代码 /// /// Converts HTML
**为您的网页提取利器——HTML到文本**
最新发布
gitblog_00035的博客
06-21 355
为您的网页提取利器——HTML到文本 html-textExtract text from HTML项目地址:https://gitcode.com/gh_mirrors/htm/html-text 在数字化时代，从网页中高效准确地提取有意义的文本信息成为了数据处理的关键环节。今天，我要向大家推荐一款强大而灵活的Python库——HTML to Text，它将帮助您轻松实现这一目标。 项目简介 ...
提取HTML代码中文字的C#函数（HTML to TEXT）
Icyplayer的专栏
07-03 1849
方法1：///提取HTML代码中文字的C#函数 /// /// 去除HTML标记 /// /// 包括HTML的源码 /// 已经去除后的文字 using System; using System.Text.RegularExpression
c html to text,How can I Convert HTML to Text in C#?
weixin_29552815的博客
06-15 123
Just a note about the HtmlAgilityPack for posterity. The project contains an example of parsing text to html, which, as noted by the OP, does not handle whitespace at all like anyone writing HTML woul...
C# 将html文本转化为 文本内容方法TextNoHTML
weixin_30907523的博客
05-12 240
不记得在哪看过这个，挺实用的 /// <summary> /// 将html文本转化为 文本内容方法TextNoHTML /// </summary> /// <param name="Htmlstring">HTML文本值</param> /// <returns></returns> public...
text代码html代码,提取HTML代码中文字的C#函数（HTML to TEXT）
weixin_39585617的博客
06-09 148
方法1：///提取HTML代码中文字的C#函数/// /// 去除HTML标记/// /// 包括HTML的源码 /// 已经去除后的文字using System;using System.Text.RegularExpressions;public class StripHTMLTest{public static void Main(){st...
C#编程资源集合包
资源摘要信息:"C#资源大全1.zip" C#（发音为“看井”）是微软开发的一种现代、类型安全的面向对象编程语言。它通常用于开发Windows应用程序、游戏、网站以及各种Web服务。C#是.NET框架的核心组成部分，与.NET运行时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值