Verwenden von regulären C # -Ausdrücken zum Entfernen von HTML-Tags

Wie verwende ich den regulären C # -Ausdruck, um alle HTML-Tags einschließlich der spitzen Klammern zu ersetzen / zu entfernen? Kann mir bitte jemand mit dem Code helfen?

Wie bereits erwähnt, sollten Sie keine regulären Ausdrücke verwenden, um XML- oder HTML-Dokumente zu verarbeiten. Sie funktionieren mit HTML- und XML-Dokumenten nicht sehr gut, da verschachtelte Strukturen nicht allgemein ausgedrückt werden können.

Sie könnten Folgendes verwenden.

String result = Regex.Replace(htmlDocument, @"<[^>]*>", String.Empty);

Dies funktioniert in den meisten Fällen, aber es gibt Fälle (z. B. CDATA mit spitzen Klammern), in denen dies nicht wie erwartet funktioniert.

Die richtige Antwort lautet: Tun Sie das nicht. Verwenden Sie das HTML Agility Pack .

Bearbeitet, um hinzuzufügen:

Um den Kommentar von Jesse schamlos zu stehlen und zu vermeiden, dass er nach all der Zeit beschuldigt wird, die Frage nicht ausreichend beantwortet zu haben, finden Sie hier einen einfachen, zuverlässigen Ausschnitt mit dem HTML Agility Pack, der selbst mit den unvollständig geformten, launischen HTML-Elementen funktioniert:

HtmlDocument doc = new HtmlDocument();
doc.LoadHtml(Properties.Resources.HtmlContents);
var text = doc.DocumentNode.SelectNodes("//body//text()").Select(node => node.InnerText);
StringBuilder output = new StringBuilder();
foreach (string line in text)
{
   output.AppendLine(line);
}
string textOnly = HttpUtility.HtmlDecode(output.ToString());

Es gibt nur sehr wenige vertretbare Fälle für die Verwendung eines regulären Ausdrucks zum Parsen von HTML, da HTML ohne ein Kontextbewusstsein, das selbst in einer nicht-traditionellen Regex-Engine sehr schmerzhaft ist, nicht korrekt analysiert werden kann. Sie können mit einem RegEx auf halbem Weg dorthin gelangen, müssen jedoch manuelle Überprüfungen durchführen.

Html Agility Pack bietet Ihnen eine robuste Lösung, mit der Sie die Aberrationen, die sich aus der naiven Behandlung von HTML als kontextfreie Grammatik ergeben können, nicht mehr manuell beheben müssen.

Ein regulärer Ausdruck kann Ihnen meistens das bringen, was Sie wollen, aber in sehr häufigen Fällen schlägt er fehl. Wenn Sie einen besseren / schnelleren Parser als HTML Agility Pack finden, versuchen Sie es, aber setzen Sie die Welt nicht mehr kaputtem HTML-Hackery aus.

Die Frage ist zu weit gefasst, um endgültig beantwortet zu werden. Sprechen Sie über das Entfernen aller Tags aus einem realen HTML-Dokument wie einer Webseite? Wenn ja, müssten Sie:

• Entfernen Sie die <! DOCTYPE-Deklaration oder das <? xml-Prolog, falls vorhanden
• Entfernen Sie alle SGML-Kommentare
• Entfernen Sie das gesamte HEAD-Element
• Entfernen Sie alle SCRIPT- und STYLE-Elemente
• Mach Grabthar-weiß-was mit FORM- und TABLE-Elementen
• Entfernen Sie die verbleibenden Tags
• Entfernen Sie die <! [CDATA [und]]> Sequenzen aus den CDATA-Abschnitten, lassen Sie jedoch deren Inhalt in Ruhe

Das ist mir ein Rätsel - ich bin mir sicher, dass es noch mehr gibt. Wenn Sie das alles erledigt haben, werden an einigen Stellen Wörter, Sätze und Absätze zusammenlaufen und an anderen große Stücke nutzloser Leerzeichen.

Angenommen, Sie arbeiten nur mit einem Fragment und können alle Tags einfach entfernen. Hier ist der reguläre Ausdruck, den ich verwenden würde:

@"(?></?\w+)(?>(?:[^>'""]+|'[^']*'|""[^""]*"")*)>"

Das Anpassen von Zeichenfolgen in einfachen und doppelten Anführungszeichen in ihren eigenen Alternativen reicht aus, um das Problem der spitzen Klammern in Attributwerten zu lösen. Ich sehe keine Notwendigkeit, die Attributnamen und andere Dinge im Tag explizit abzugleichen, wie es der reguläre Ausdruck in Ryans Antwort tut. Die erste Alternative erledigt all das.

Falls Sie sich über diese (?>...)Konstrukte wundern , handelt es sich um Atomgruppen . Sie machen den Regex ein wenig effizienter, aber was noch wichtiger ist, sie verhindern ein außer Kontrolle geratenes Backtracking, worauf Sie immer achten sollten, wenn Sie wie ich Alternation und verschachtelte Quantifizierer mischen. Ich denke nicht wirklich, dass das hier ein Problem wäre, aber ich weiß, wenn ich es nicht erwähne, wird es jemand anderes tun. ;-);

Diese Regex ist natürlich nicht perfekt, aber wahrscheinlich so gut, wie Sie es jemals brauchen werden.

Regex regex = new Regex(@"</?\w+((\s+\w+(\s*=\s*(?:"".*?""|'.*?'|[^'"">\s]+))?)+\s*|\s*)/?>", RegexOptions.Singleline);

Quelle

@JasonTrue ist richtig, dass das Entfernen von HTML-Tags nicht über reguläre Ausdrücke erfolgen sollte.

Es ist ganz einfach, HTML-Tags mit HtmlAgilityPack zu entfernen:

public string StripTags(string input) {
    var doc = new HtmlDocument();
    doc.LoadHtml(input ?? "");
    return doc.DocumentNode.InnerText;
}

Ich möchte Jasons Antwort wiederholen, obwohl Sie manchmal naiv etwas HTML analysieren und den Textinhalt herausziehen müssen.

Ich musste dies mit etwas HTML tun, das von einem Rich-Text-Editor erstellt wurde, immer Spaß und Spiel.

In diesem Fall müssen Sie möglicherweise den Inhalt einiger Tags sowie nur die Tags selbst entfernen.

In meinem Fall wurden Tags in diese Mischung geworfen. Jemand mag meine (sehr geringfügig) weniger naive Implementierung als nützlichen Ausgangspunkt betrachten.

   /// <summary>
    /// Removes all html tags from string and leaves only plain text
    /// Removes content of <xml></xml> and <style></style> tags as aim to get text content not markup /meta data.
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public static string HtmlStrip(this string input)
    {
        input = Regex.Replace(input, "<style>(.|\n)*?</style>",string.Empty);
        input = Regex.Replace(input, @"<xml>(.|\n)*?</xml>", string.Empty); // remove all <xml></xml> tags and anything inbetween.  
        return Regex.Replace(input, @"<(.|\n)*?>", string.Empty); // remove any tags but not there content "<p>bob<span> johnson</span></p>" becomes "bob johnson"
    }

Versuchen Sie es mit der Methode für reguläre Ausdrücke unter folgender URL: http://www.dotnetperls.com/remove-html-tags

/// <summary>
/// Remove HTML from string with Regex.
/// </summary>
public static string StripTagsRegex(string source)
{
return Regex.Replace(source, "<.*?>", string.Empty);
}

/// <summary>
/// Compiled regular expression for performance.
/// </summary>
static Regex _htmlRegex = new Regex("<.*?>", RegexOptions.Compiled);

/// <summary>
/// Remove HTML from string with compiled Regex.
/// </summary>
public static string StripTagsRegexCompiled(string source)
{
return _htmlRegex.Replace(source, string.Empty);
}

benutze das..

@"(?></?\w+)(?>(?:[^>'""]+|'[^']*'|""[^""]*"")*)>"

Fügen Sie .+?in <[^>]*>und versuchen , diese regex (Basis auf diese ):

<[^>].+?>

c # .net Regex Demo

Verwenden Sie diese Methode, um Tags zu entfernen:

public string From_To(string text, string from, string to)
{
    if (text == null)
        return null;
    string pattern = @"" + from + ".*?" + to;
    Regex rx = new Regex(pattern, RegexOptions.Compiled | RegexOptions.IgnoreCase);
    MatchCollection matches = rx.Matches(text);
    return matches.Count <= 0 ? text : matches.Cast<Match>().Where(match => !string.IsNullOrEmpty(match.Value)).Aggregate(text, (current, match) => current.Replace(match.Value, ""));
}