Usando expressões regulares em C # para remover tags HTML

Como uso a expressão regular C # para substituir / remover todas as tags HTML, incluindo os colchetes angulares? Alguém por favor pode me ajudar com o código?

Como dito anteriormente, você não deve usar expressões regulares para processar documentos XML ou HTML. Eles não funcionam muito bem com documentos HTML e XML, porque não há como expressar estruturas aninhadas de maneira geral.

Você pode usar o seguinte.

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

Isso funcionará na maioria dos casos, mas haverá casos (por exemplo, CDATA contendo colchetes angulares) em que isso não funcionará conforme o esperado.

A resposta correta é não fazer isso, use o HTML Agility Pack .

Editado para adicionar:

Para roubar descaradamente o comentário abaixo de jesse e evitar ser acusado de responder inadequadamente à pergunta depois de todo esse tempo, aqui está um trecho simples e confiável usando o HTML Agility Pack que funciona com os bits caprichosos de HTML ainda mais imperfeitos:

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

Existem muito poucos casos defensáveis ​​para o uso de uma expressão regular para analisar HTML, pois o HTML não pode ser analisado corretamente sem uma conscientização de contexto que é muito dolorosa de fornecer, mesmo em um mecanismo de regex não tradicional. Você pode chegar até lá com um RegEx, mas precisará fazer verificações manuais.

O Html Agility Pack pode fornecer uma solução robusta que reduzirá a necessidade de corrigir manualmente as aberrações que podem resultar do tratamento ingênuo do HTML como uma gramática livre de contexto.

Uma expressão regular pode obter o que você deseja na maioria das vezes, mas falhará em casos muito comuns. Se você puder encontrar um analisador melhor / mais rápido que o HTML Agility Pack, vá em frente, mas não sujeite o mundo a mais invasões de HTML quebradas.

A questão é muito ampla para ser respondida definitivamente. Você está falando sobre remover todas as tags de um documento HTML do mundo real, como uma página da web? Nesse caso, você teria que:

• remova a declaração <! DOCTYPE ou o prólogo <? xml, se existir
• remova todos os comentários SGML
• remova todo o elemento HEAD
• remova todos os elementos SCRIPT e STYLE
• Grabthar-sabe-o que com elementos FORM e TABLE
• remova as tags restantes
• remova as seqüências <! [CDATA [e]]> das seções CDATA, mas deixe seu conteúdo em paz

Isso está no topo da minha cabeça - tenho certeza de que há mais. Depois de fazer tudo isso, você terminará com palavras, frases e parágrafos juntos em alguns lugares, e grandes pedaços de espaço em branco inútil em outros.

Mas, supondo que você esteja trabalhando apenas com um fragmento e possa simplesmente remover todas as tags, aqui está o regex que eu usaria:

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

A correspondência de cadeias simples e duplas em suas próprias alternativas é suficiente para lidar com o problema de colchetes angulares nos valores de atributo. Não vejo necessidade de corresponder explicitamente os nomes dos atributos e outras coisas dentro da tag, como faz o regex na resposta de Ryan; a primeira alternativa lida com tudo isso.

Caso você esteja se perguntando sobre essas (?>...)construções, são grupos atômicos . Eles tornam o regex um pouco mais eficiente, mas, o mais importante, evitam o retrocesso descontrolado, o que é algo que você sempre deve observar ao misturar quantificadores alternados e aninhados, como eu fiz. Eu realmente não acho que seria um problema aqui, mas sei que se não mencionar, alguém o fará. ;-)

Esse regex não é perfeito, é claro, mas provavelmente é tão bom quanto você precisará.

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

Fonte

@JasonTrue está correto, que a remoção de tags HTML não deve ser feita por meio de expressões regulares.

É bastante simples remover tags HTML usando HtmlAgilityPack:

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

Gostaria de repetir a resposta de Jason, embora às vezes você precise analisar ingenuamente algum HTML e extrair o conteúdo do texto.

Eu precisava fazer isso com um pouco de HTML, criado por um editor de texto rico, sempre divertido e com jogos.

Nesse caso, pode ser necessário remover o conteúdo de algumas tags, bem como apenas as próprias tags.

No meu caso, as tags foram lançadas nesse mix. Alguém pode achar minha implementação (um pouco) menos ingênua um ponto de partida útil.

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

tente o método de expressão regular neste 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 isto..

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

Adicionar .+?em <[^>]*>e experimentar este regex (base sobre este ):

<[^>].+?>

demonstração de regex do c # .net

Use este método para remover tags:

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