لدي قصاصات من HTML المخزنة في الجدول. ليست صفحات كاملة ، لا علامات أو ما شابه ، فقط التنسيق الأساسي.
أود أن أكون قادرًا على عرض هذا Html كنص فقط ، بدون تنسيق ، على صفحة معينة (في الحقيقة فقط 30 إلى 50 حرفًا ولكن هذا هو الشيء السهل).
كيف يمكنني وضع "النص" داخل Html في سلسلة كنص مستقيم؟
لذلك هذه القطعة من الكود.
<b>Hello World.</b><br/><p><i>Is there anyone out there?</i><p>
يصبح:
مرحبا بالعالم. هل هناك أي شخص هناك؟
إذا كنت تتحدث عن تجريد العلامات ، فسيتم ذلك بشكل مستقيم نسبياً إلى الأمام إذا لم يكن لديك ما يدعو للقلق بشأن أشياء مثل علامات <script>
. إذا كان كل ما عليك فعله هو عرض النص بدون العلامات ، فيمكنك إنجاز ذلك باستخدام تعبير عادي:
<[^>]*>
إذا كان لديك ما يدعو للقلق بشأن علامات <script>
وما شابه ذلك ، فستحتاج إلى شيء أكثر تعبيرًا ثم تعبيرًا منتظمًا لأنك تحتاج إلى تتبع الحالة ، أشبه بنحو سياق مجاني (CFG). على الرغم من أنك قد تكون قادرًا على تحقيق ذلك باستخدام "من اليسار إلى اليمين" أو مطابقة غير جشعة.
إذا كنت تستطيع استخدام التعبيرات العادية ، فهناك العديد من صفحات الويب الموجودة بها معلومات جيدة:
إذا كنت بحاجة إلى سلوك أكثر تعقيدًا لـ CFG ، فإنني أقترح استخدام أداة تابعة لجهة خارجية ، للأسف لا أعرف جيدًا لأوصي به.
المصدر المجاني والمفتوح HtmlAgilityPack has في إحدى عيناته طريقة تحول من HTML إلى نص عادي.
var plainText = HtmlUtilities.ConvertToPlainText(string html);
إطعامها سلسلة HTML مثل
<b>hello, <i>world!</i></b>
وستحصل على نتيجة نص عادي مثل:
hello world!
لم أستطع استخدام HtmlAgilityPack ، لذلك كتبت ثاني أفضل حل لنفسي
private static string HtmlToPlainText(string html)
{
const string tagWhiteSpace = @"(>|$)(\W|\n|\r)+<";//matches one or more (white space or line breaks) between '>' and '<'
const string stripFormatting = @"<[^>]*(>|$)";//match any character between '<' and '>', even when end tag is missing
const string lineBreak = @"<(br|BR)\s{0,1}\/{0,1}>";//matches: <br>,<br/>,<br />,<BR>,<BR/>,<BR />
var lineBreakRegex = new Regex(lineBreak, RegexOptions.Multiline);
var stripFormattingRegex = new Regex(stripFormatting, RegexOptions.Multiline);
var tagWhiteSpaceRegex = new Regex(tagWhiteSpace, RegexOptions.Multiline);
var text = html;
//Decode html specific characters
text = System.Net.WebUtility.HtmlDecode(text);
//Remove tag whitespace/line breaks
text = tagWhiteSpaceRegex.Replace(text, "><");
//Replace <br /> with line breaks
text = lineBreakRegex.Replace(text, Environment.NewLine);
//Strip formatting
text = stripFormattingRegex.Replace(text, string.Empty);
return text;
}
HTTPUtility.HTMLEncode()
تهدف إلى معالجة ترميز علامات HTML كسلاسل. إنه يعتني بكافة الأحمال الثقيلة. من وثائق MSDN :
إذا تم تمرير أحرف مثل الفراغات وعلامات الترقيم في دفق HTTP ، فقد يتم إساءة تفسيرها في الطرف المتلقي. يقوم ترميز HTML بتحويل الأحرف غير المسموح بها في HTML إلى مكافئات كيان الأحرف ؛ فك ترميز HTML يعكس الترميز. على سبيل المثال ، عند تضمينها في كتلة نصية ، يتم تشفير الأحرف
<
و>
، كـ<
و>
لنقل HTTP.
HTTPUtility.HTMLEncode()
طريقة ، مفصلة هنا :
public static void HtmlEncode(
string s,
TextWriter output
)
الاستعمال:
String TestString = "This is a <Test String>.";
StringWriter writer = new StringWriter();
Server.HtmlEncode(TestString, writer);
String EncodedString = writer.ToString();
للإضافة إلى إجابة vfilby ، يمكنك فقط إجراء استبدال RegEx ضمن التعليمات البرمجية الخاصة بك ؛ لا الطبقات الجديدة ضرورية. في حال كان المبتدئون الآخرون مثلي يعثرون على هذا السؤال.
using System.Text.RegularExpressions;
ثم...
private string StripHtml(string source)
{
string output;
//get rid of HTML tags
output = Regex.Replace(source, "<[^>]*>", string.Empty);
//get rid of multiple blank lines
output = Regex.Replace(output, @"^\s*$\n", string.Empty, RegexOptions.Multiline);
return output;
}
ثلاث خطوات عملية لتحويل HTML إلى نص عادي
تحتاج أولاً إلى تثبيت حزمة Nuget لـ HtmlAgilityPack Second إنشاء هذه الفئة
public class HtmlToText
{
public HtmlToText()
{
}
public string Convert(string path)
{
HtmlDocument doc = new HtmlDocument();
doc.Load(path);
StringWriter sw = new StringWriter();
ConvertTo(doc.DocumentNode, sw);
sw.Flush();
return sw.ToString();
}
public string ConvertHtml(string html)
{
HtmlDocument doc = new HtmlDocument();
doc.LoadHtml(html);
StringWriter sw = new StringWriter();
ConvertTo(doc.DocumentNode, sw);
sw.Flush();
return sw.ToString();
}
private void ConvertContentTo(HtmlNode node, TextWriter outText)
{
foreach(HtmlNode subnode in node.ChildNodes)
{
ConvertTo(subnode, outText);
}
}
public void ConvertTo(HtmlNode node, TextWriter outText)
{
string html;
switch(node.NodeType)
{
case HtmlNodeType.Comment:
// don't output comments
break;
case HtmlNodeType.Document:
ConvertContentTo(node, outText);
break;
case HtmlNodeType.Text:
// script and style must not be output
string parentName = node.ParentNode.Name;
if ((parentName == "script") || (parentName == "style"))
break;
// get text
html = ((HtmlTextNode)node).Text;
// is it in fact a special closing node output as text?
if (HtmlNode.IsOverlappedClosingElement(html))
break;
// check the text is meaningful and not a bunch of whitespaces
if (html.Trim().Length > 0)
{
outText.Write(HtmlEntity.DeEntitize(html));
}
break;
case HtmlNodeType.Element:
switch(node.Name)
{
case "p":
// treat paragraphs as crlf
outText.Write("\r\n");
break;
}
if (node.HasChildNodes)
{
ConvertContentTo(node, outText);
}
break;
}
}
}
باستخدام الصف أعلاه مع الإشارة إلى إجابة يهوذا Himango
ثالثًا ، تحتاج إلى إنشاء كائن الفئة أعلاه واستخدام ConvertHtml(HTMLContent)
Method لتحويل HTML إلى نص عادي بدلاً من ConvertToPlainText(string html);
HtmlToText htt=new HtmlToText();
var plainText = htt.ConvertHtml(HTMLContent);
أبسط طريقة وجدت:
HtmlFilter.ConvertToPlainText(html);
توجد فئة HtmlFilter في Microsoft.TeamFoundation.WorkItemTracking.Controls.dll
يمكن العثور على dll في مجلد مثل هذا:٪ ProgramFiles٪\Common Files\Microsoft Shared\Team Foundation Server\14.0 \
في VS 2015 ، يتطلب ملف dll أيضًا الرجوع إلى Microsoft.TeamFoundation.WorkItemTracking.Common.dll ، الموجود في نفس المجلد.
لا توجد طريقة تحمل اسم "ConvertToPlainText" في HtmlAgilityPack ولكن يمكنك تحويل سلسلة html إلى سلسلة CLEAR باستخدام:
HtmlDocument doc = new HtmlDocument();
doc.LoadHtml(htmlString);
var textString = doc.DocumentNode.InnerText;
Regex.Replace(textString , @"<(.|n)*?>", string.Empty).Replace(" ", "");
هذا يعمل بالنسبة لي. لكنني لا أجد طريقة تحمل الاسم "ConvertToPlainText" في "HtmlAgilityPack".
لديها قيود على عدم انهيار مسافة بيضاء مضمنة طويلة ، لكنها بالتأكيد محمولة وتحترم التصميم مثل webbrowser.
static string HtmlToPlainText(string html) {
string buf;
string block = "address|article|aside|blockquote|canvas|dd|div|dl|dt|" +
"fieldset|figcaption|figure|footer|form|h\\d|header|hr|li|main|nav|" +
"noscript|ol|output|p|pre|section|table|tfoot|ul|video";
string patNestedBlock = $"(\\s*?</?({block})[^>]*?>)+\\s*";
buf = Regex.Replace(html, patNestedBlock, "\n", RegexOptions.IgnoreCase);
// Replace br tag to newline.
buf = Regex.Replace(buf, @"<(br)[^>]*>", "\n", RegexOptions.IgnoreCase);
// (Optional) remove styles and scripts.
buf = Regex.Replace(buf, @"<(script|style)[^>]*?>.*?</\1>", "", RegexOptions.Singleline);
// Remove all tags.
buf = Regex.Replace(buf, @"<[^>]*(>|$)", "", RegexOptions.Multiline);
// Replace HTML entities.
buf = WebUtility.HtmlDecode(buf);
return buf;
}
أعتقد أن أسهل طريقة هي إنشاء طريقة امتداد "سلسلة" (بناءً على ما اقترحه ريتشارد):
using System;
using System.Text.RegularExpressions;
public static class StringHelpers
{
public static string StripHTML(this string HTMLText)
{
var reg = new Regex("<[^>]+>", RegexOptions.IgnoreCase);
return reg.Replace(HTMLText, "");
}
}
ثم استخدم طريقة الامتداد هذه في أي متغير "string" في البرنامج:
var yourHtmlString = "<div class=\"someclass\"><h2>yourHtmlText</h2></span>";
var yourTextString = yourHtmlString.StripHTML();
أستخدم طريقة الامتداد هذه لتحويل التعليقات المنسقة بتنسيق html إلى نص عادي حتى يتم عرضها بشكل صحيح على تقرير بلوري ، وتعمل بشكل مثالي!
إذا كان لديك بيانات تحتوي على علامات HTML وتريد عرضها حتى يتمكن أي شخص من رؤية العلامات ، فاستخدم HttpServerUtility :: HtmlEncode.
إذا كانت لديك بيانات تحتوي على علامات HTML فيها وترغب في أن يرى المستخدم العلامات المقدمة ، فقم بعرض النص كما هو. إذا كان النص يمثل صفحة ويب كاملة ، فاستخدم IFRAME لها.
إذا كان لديك بيانات تحتوي على علامات HTML وتريد حذف العلامات وعرض النص غير المنسق ، استخدم تعبيرًا عاديًا.
لقد واجهت مشكلة مماثلة ووجدت أفضل حل. أدناه رمز يعمل مثالية بالنسبة لي.
private string ConvertHtml_Totext(string source)
{
try
{
string result;
// Remove HTML Development formatting
// Replace line breaks with space
// because browsers inserts space
result = source.Replace("\r", " ");
// Replace line breaks with space
// because browsers inserts space
result = result.Replace("\n", " ");
// Remove step-formatting
result = result.Replace("\t", string.Empty);
// Remove repeating spaces because browsers ignore them
result = System.Text.RegularExpressions.Regex.Replace(result,
@"( )+", " ");
// Remove the header (prepare first by clearing attributes)
result = System.Text.RegularExpressions.Regex.Replace(result,
@"<( )*head([^>])*>","<head>",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
@"(<( )*(/)( )*head( )*>)","</head>",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
"(<head>).*(</head>)",string.Empty,
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
// remove all scripts (prepare first by clearing attributes)
result = System.Text.RegularExpressions.Regex.Replace(result,
@"<( )*script([^>])*>","<script>",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
@"(<( )*(/)( )*script( )*>)","</script>",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
//result = System.Text.RegularExpressions.Regex.Replace(result,
// @"(<script>)([^(<script>\.</script>)])*(</script>)",
// string.Empty,
// System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
@"(<script>).*(</script>)",string.Empty,
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
// remove all styles (prepare first by clearing attributes)
result = System.Text.RegularExpressions.Regex.Replace(result,
@"<( )*style([^>])*>","<style>",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
@"(<( )*(/)( )*style( )*>)","</style>",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
"(<style>).*(</style>)",string.Empty,
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
// insert tabs in spaces of <td> tags
result = System.Text.RegularExpressions.Regex.Replace(result,
@"<( )*td([^>])*>","\t",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
// insert line breaks in places of <BR> and <LI> tags
result = System.Text.RegularExpressions.Regex.Replace(result,
@"<( )*br( )*>","\r",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
@"<( )*li( )*>","\r",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
// insert line paragraphs (double line breaks) in place
// if <P>, <DIV> and <TR> tags
result = System.Text.RegularExpressions.Regex.Replace(result,
@"<( )*div([^>])*>","\r\r",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
@"<( )*tr([^>])*>","\r\r",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
@"<( )*p([^>])*>","\r\r",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
// Remove remaining tags like <a>, links, images,
// comments etc - anything that's enclosed inside < >
result = System.Text.RegularExpressions.Regex.Replace(result,
@"<[^>]*>",string.Empty,
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
// replace special characters:
result = System.Text.RegularExpressions.Regex.Replace(result,
@" "," ",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
@"•"," * ",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
@"‹","<",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
@"›",">",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
@"™","(tm)",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
@"⁄","/",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
@"<","<",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
@">",">",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
@"©","(c)",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
@"®","(r)",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
// Remove all others. More can be added, see
// http://hotwired.lycos.com/webmonkey/reference/special_characters/
result = System.Text.RegularExpressions.Regex.Replace(result,
@"&(.{2,6});", string.Empty,
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
// for testing
//System.Text.RegularExpressions.Regex.Replace(result,
// this.txtRegex.Text,string.Empty,
// System.Text.RegularExpressions.RegexOptions.IgnoreCase);
// make line breaking consistent
result = result.Replace("\n", "\r");
// Remove extra line breaks and tabs:
// replace over 2 breaks with 2 and over 4 tabs with 4.
// Prepare first to remove any whitespaces in between
// the escaped characters and remove redundant tabs in between line breaks
result = System.Text.RegularExpressions.Regex.Replace(result,
"(\r)( )+(\r)","\r\r",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
"(\t)( )+(\t)","\t\t",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
"(\t)( )+(\r)","\t\r",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
result = System.Text.RegularExpressions.Regex.Replace(result,
"(\r)( )+(\t)","\r\t",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
// Remove redundant tabs
result = System.Text.RegularExpressions.Regex.Replace(result,
"(\r)(\t)+(\r)","\r\r",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
// Remove multiple tabs following a line break with just one tab
result = System.Text.RegularExpressions.Regex.Replace(result,
"(\r)(\t)+","\r\t",
System.Text.RegularExpressions.RegexOptions.IgnoreCase);
// Initial replacement target string for line breaks
string breaks = "\r\r\r";
// Initial replacement target string for tabs
string tabs = "\t\t\t\t\t";
for (int index=0; index<result.Length; index++)
{
result = result.Replace(breaks, "\r\r");
result = result.Replace(tabs, "\t\t\t\t");
breaks = breaks + "\r";
tabs = tabs + "\t";
}
// That's it.
return result;
}
catch
{
MessageBox.Show("Error");
return source;
}
}
كان لا بد من إزالة شخصيات الهروب مثل\n و\r أولاً لأنها تتسبب في توقف عمل regexes كما هو متوقع.
علاوة على ذلك ، لجعل سلسلة النتائج معروضة بشكل صحيح في مربع النص ، قد يحتاج المرء إلى تقسيمها وتعيين خاصية Lines في مربع النص بدلاً من تعيينها إلى خاصية Text.
this.txtResult.Lines = StripHTML (this.txtSource.Text) .Split ("\ r" .ToCharArray ())؛
المصدر: https://www.codeproject.com/Articles/11902/Convert-HTML-to-Plain-Text-2
كان لدي نفس السؤال ، فقط أتش تي أم أل لدي تصميم بسيط معروف مسبقًا ، مثل:
<DIV><P>abc</P><P>def</P></DIV>
لذلك انتهى بي الأمر باستخدام مثل هذا الرمز البسيط:
string.Join (Environment.NewLine, XDocument.Parse (html).Root.Elements ().Select (el => el.Value))
أي النواتج:
abc
def
إليكم الحل:
public string StripHTML(string html)
{
var regex = new Regex("<[^>]+>", RegexOptions.IgnoreCase);
return System.Web.HttpUtility.HtmlDecode((regex.Replace(html, "")));
}
مثال:
StripHTML("<p class='test' style='color:red;'>Here is my solution:</p>");
// output -> Here is my solution:
يعتمد على ما تعنيه بـ "html". الحالة الأكثر تعقيدًا ستكون صفحات الويب كاملة. هذا أيضًا هو أسهل التعامل معه ، حيث يمكنك استخدام مستعرض ويب وضع النص. انظر مقالة ويكيبيديا سرد متصفحات الويب ، بما في ذلك متصفحات وضع النص. من المحتمل أن الوشق هو الأكثر شهرة ، لكن أحد الآخرين قد يكون أفضل لاحتياجاتك.
لم يكتب ولكن باستخدام:
using HtmlAgilityPack;
using System;
using System.IO;
using System.Text.RegularExpressions;
namespace foo {
//small but important modification to class https://github.com/zzzprojects/html-agility-pack/blob/master/src/Samples/Html2Txt/HtmlConvert.cs
public static class HtmlToText {
public static string Convert(string path) {
HtmlDocument doc = new HtmlDocument();
doc.Load(path);
return ConvertDoc(doc);
}
public static string ConvertHtml(string html) {
HtmlDocument doc = new HtmlDocument();
doc.LoadHtml(html);
return ConvertDoc(doc);
}
public static string ConvertDoc(HtmlDocument doc) {
using (StringWriter sw = new StringWriter()) {
ConvertTo(doc.DocumentNode, sw);
sw.Flush();
return sw.ToString();
}
}
internal static void ConvertContentTo(HtmlNode node, TextWriter outText, PreceedingDomTextInfo textInfo) {
foreach (HtmlNode subnode in node.ChildNodes) {
ConvertTo(subnode, outText, textInfo);
}
}
public static void ConvertTo(HtmlNode node, TextWriter outText) {
ConvertTo(node, outText, new PreceedingDomTextInfo(false));
}
internal static void ConvertTo(HtmlNode node, TextWriter outText, PreceedingDomTextInfo textInfo) {
string html;
switch (node.NodeType) {
case HtmlNodeType.Comment:
// don't output comments
break;
case HtmlNodeType.Document:
ConvertContentTo(node, outText, textInfo);
break;
case HtmlNodeType.Text:
// script and style must not be output
string parentName = node.ParentNode.Name;
if ((parentName == "script") || (parentName == "style")) {
break;
}
// get text
html = ((HtmlTextNode)node).Text;
// is it in fact a special closing node output as text?
if (HtmlNode.IsOverlappedClosingElement(html)) {
break;
}
// check the text is meaningful and not a bunch of whitespaces
if (html.Length == 0) {
break;
}
if (!textInfo.WritePrecedingWhiteSpace || textInfo.LastCharWasSpace) {
html = html.TrimStart();
if (html.Length == 0) { break; }
textInfo.IsFirstTextOfDocWritten.Value = textInfo.WritePrecedingWhiteSpace = true;
}
outText.Write(HtmlEntity.DeEntitize(Regex.Replace(html.TrimEnd(), @"\s{2,}", " ")));
if (textInfo.LastCharWasSpace = char.IsWhiteSpace(html[html.Length - 1])) {
outText.Write(' ');
}
break;
case HtmlNodeType.Element:
string endElementString = null;
bool isInline;
bool skip = false;
int listIndex = 0;
switch (node.Name) {
case "nav":
skip = true;
isInline = false;
break;
case "body":
case "section":
case "article":
case "aside":
case "h1":
case "h2":
case "header":
case "footer":
case "address":
case "main":
case "div":
case "p": // stylistic - adjust as you tend to use
if (textInfo.IsFirstTextOfDocWritten) {
outText.Write("\r\n");
}
endElementString = "\r\n";
isInline = false;
break;
case "br":
outText.Write("\r\n");
skip = true;
textInfo.WritePrecedingWhiteSpace = false;
isInline = true;
break;
case "a":
if (node.Attributes.Contains("href")) {
string href = node.Attributes["href"].Value.Trim();
if (node.InnerText.IndexOf(href, StringComparison.InvariantCultureIgnoreCase) == -1) {
endElementString = "<" + href + ">";
}
}
isInline = true;
break;
case "li":
if (textInfo.ListIndex > 0) {
outText.Write("\r\n{0}.\t", textInfo.ListIndex++);
} else {
outText.Write("\r\n*\t"); //using '*' as bullet char, with tab after, but whatever you want eg "\t->", if utf-8 0x2022
}
isInline = false;
break;
case "ol":
listIndex = 1;
goto case "ul";
case "ul": //not handling nested lists any differently at this stage - that is getting close to rendering problems
endElementString = "\r\n";
isInline = false;
break;
case "img": //inline-block in reality
if (node.Attributes.Contains("alt")) {
outText.Write('[' + node.Attributes["alt"].Value);
endElementString = "]";
}
if (node.Attributes.Contains("src")) {
outText.Write('<' + node.Attributes["src"].Value + '>');
}
isInline = true;
break;
default:
isInline = true;
break;
}
if (!skip && node.HasChildNodes) {
ConvertContentTo(node, outText, isInline ? textInfo : new PreceedingDomTextInfo(textInfo.IsFirstTextOfDocWritten) { ListIndex = listIndex });
}
if (endElementString != null) {
outText.Write(endElementString);
}
break;
}
}
}
internal class PreceedingDomTextInfo {
public PreceedingDomTextInfo(BoolWrapper isFirstTextOfDocWritten) {
IsFirstTextOfDocWritten = isFirstTextOfDocWritten;
}
public bool WritePrecedingWhiteSpace { get; set; }
public bool LastCharWasSpace { get; set; }
public readonly BoolWrapper IsFirstTextOfDocWritten;
public int ListIndex { get; set; }
}
internal class BoolWrapper {
public BoolWrapper() { }
public bool Value { get; set; }
public static implicit operator bool(BoolWrapper boolWrapper) {
return boolWrapper.Value;
}
public static implicit operator BoolWrapper(bool boolWrapper) {
return new BoolWrapper { Value = boolWrapper };
}
}
}