Utilizzo delle espressioni regolari C # per rimuovere i tag HTML

Come uso l'espressione regolare C # per sostituire / rimuovere tutti i tag HTML, comprese le parentesi angolari? Qualcuno può aiutarmi con il codice, per favore?

Come spesso affermato in precedenza, non è necessario utilizzare espressioni regolari per elaborare documenti XML o HTML. Non si comportano molto bene con i documenti HTML e XML, perché non c'è modo di esprimere strutture nidificate in modo generale.

È possibile utilizzare quanto segue.

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

Funzionerà nella maggior parte dei casi, ma ci saranno casi (ad esempio CDATA contenenti parentesi angolari) in cui ciò non funzionerà come previsto.

La risposta corretta è non farlo, usa HTML Agility Pack .

Modificato per aggiungere:

Per sottrarre spudoratamente dal commento qui sotto di jesse ed evitare di essere accusato di rispondere inadeguatamente alla domanda dopo tutto questo tempo, ecco un semplice e affidabile snippet che utilizza HTML Agility Pack che funziona anche con bit capricciosi di HTML formati in modo più imperfetto:

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());

Esistono pochissimi casi difendibili per l'uso di un'espressione regolare per l'analisi dell'HTML, poiché l'HTML non può essere analizzato correttamente senza una consapevolezza del contesto che è molto dolorosa da fornire anche in un motore regex non tradizionale. Puoi arrivare a metà strada con un RegEx, ma dovrai fare delle verifiche manuali.

Html Agility Pack può fornirti una soluzione solida che ridurrà la necessità di correggere manualmente le aberrazioni che possono derivare dal trattamento ingenuo dell'HTML come una grammatica senza contesto.

Un'espressione regolare può darti principalmente quello che vuoi per la maggior parte del tempo, ma fallirà in casi molto comuni. Se riesci a trovare un parser migliore / più veloce di HTML Agility Pack, provalo, ma per favore non sottoporre il mondo a hacker HTML più rotti.

La domanda è troppo ampia per essere risolta definitivamente. Stai parlando di rimuovere tutti i tag da un documento HTML del mondo reale, come una pagina web? In tal caso, dovresti:

• rimuovere la dichiarazione <! DOCTYPE o il prologo <? xml se esistono
• rimuovi tutti i commenti SGML
• rimuovere l'intero elemento HEAD
• rimuovere tutti gli elementi SCRIPT e STYLE
• Grabthar-sa-cosa con gli elementi FORM e TABLE
• rimuovere i tag rimanenti
• rimuovere le sequenze <! [CDATA [e]]> dalle sezioni CDATA ma lasciare solo il loro contenuto

Questo è appena fuori dalla mia testa - Sono sicuro che c'è di più. Una volta che hai fatto tutto ciò, finirai con parole, frasi e paragrafi che corrono insieme in alcuni punti e grossi pezzi di spazio bianco inutile in altri.

Ma supponendo che tu stia lavorando con solo un frammento e che tu possa cavartela semplicemente rimuovendo tutti i tag, ecco la regex che userei:

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

La corrispondenza di stringhe tra virgolette singole e doppie nelle loro alternative è sufficiente per affrontare il problema delle parentesi angolari nei valori degli attributi. Non vedo alcun bisogno di abbinare esplicitamente i nomi degli attributi e altre cose all'interno del tag, come fa la regex nella risposta di Ryan; la prima alternativa gestisce tutto ciò.

Nel caso ti stia chiedendo di quei (?>...)costrutti, sono gruppi atomici . Rendono il regex un po 'più efficiente, ma, cosa più importante, impediscono il backtracking in fuga, che è qualcosa a cui dovresti sempre fare attenzione quando mescoli alternanza e quantificatori annidati come ho fatto. Non penso davvero che sarebbe un problema qui, ma so che se non lo menzionassi, lo farà qualcun altro. ;-)

Questo regex non è perfetto, ovviamente, ma è probabilmente buono come non ne avrai mai bisogno.

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

fonte

@JasonTrue ha ragione, che lo stripping dei tag HTML non dovrebbe essere fatto tramite espressioni regolari.

È abbastanza semplice rimuovere i tag HTML usando HtmlAgilityPack:

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

Vorrei fare eco alla risposta di Jason, anche se a volte è necessario analizzare ingenuamente un po 'di HTML e estrarre il contenuto del testo.

Ho dovuto farlo con un po 'di HTML che era stato creato da un ricco editor di testi, sempre divertente e con giochi.

In questo caso potrebbe essere necessario rimuovere il contenuto di alcuni tag e solo i tag stessi.

Nel mio caso e tag sono stati gettati in questo mix. Qualcuno potrebbe trovare la mia (molto leggermente) meno ingenua implementazione un utile punto di partenza.

   /// <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"
    }

prova il metodo delle espressioni regolari a questo 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);
}

Usa questo..

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

Aggiungere .+?in <[^>]*>e provare questo regex (base su questo ):

<[^>].+?>

c # .net regex demo

Utilizzare questo metodo per rimuovere i tag:

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, ""));
}