Como retirar as tags HTML de uma string no ASP.NET?

Usando o ASP.NET, como posso retirar as tags HTML de uma determinada string de maneira confiável (ou seja, não usando regex)? Eu estou procurando algo como PHP strip_tags.

Exemplo:

<ul><li>Hello</li></ul>

Resultado:

"Olá"

Estou tentando não reinventar a roda, mas ainda não encontrei nada que atenda às minhas necessidades.

Se estiver apenas retirando todas as tags HTML de uma sequência, isso funcionará de maneira confiável também com o regex. Substituir:

<[^>]*(>|$)

com a cadeia vazia, globalmente. Não se esqueça de normalizar a sequência posteriormente, substituindo:

[\s\r\n]+

com um único espaço e aparando o resultado. Opcionalmente, substitua quaisquer entidades de caracteres HTML de volta aos caracteres reais.

Nota :

1. Há uma limitação: HTML e XML permitem >valores de atributo. Esta solução irá retornar marcação quebrado quando se deparam com tais valores.
2. A solução é tecnicamente segura, como em: O resultado nunca conterá nada que possa ser usado para executar scripts entre sites ou interromper o layout de uma página. Não é apenas muito limpo.
3. Como em todas as coisas em HTML e regex:
   use um analisador adequado se você precisar corrigi-lo em todas as circunstâncias.

Vá baixar HTMLAgilityPack, agora! ;) Baixar LInk

Isso permite carregar e analisar o HTML. Em seguida, você pode navegar pelo DOM e extrair os valores internos de todos os atributos. Sério, você levará cerca de 10 linhas de código no máximo. É uma das maiores bibliotecas .net gratuitas disponíveis no mercado.

Aqui está uma amostra:

            string htmlContents = new System.IO.StreamReader(resultsStream,Encoding.UTF8,true).ReadToEnd();

            HtmlAgilityPack.HtmlDocument doc = new HtmlAgilityPack.HtmlDocument();
            doc.LoadHtml(htmlContents);
            if (doc == null) return null;

            string output = "";
            foreach (var node in doc.DocumentNode.ChildNodes)
            {
                output += node.InnerText;
            }

Regex.Replace(htmlText, "<.*?>", string.Empty);

protected string StripHtml(string Txt)
{
    return Regex.Replace(Txt, "<(.|\\n)*?>", string.Empty);
}    

Protected Function StripHtml(Txt as String) as String
    Return Regex.Replace(Txt, "<(.|\n)*?>", String.Empty)
End Function

Eu publiquei isso nos fóruns do asp.net, e ainda parece ser uma das soluções mais fáceis por aí. Não garanto que seja o mais rápido ou mais eficiente, mas é bastante confiável. No .NET, você pode usar os próprios objetos HTML Web Control. Tudo o que você realmente precisa fazer é inserir sua string em um objeto HTML temporário, como um DIV, e usar o 'InnerText' interno para capturar todo o texto que não está contido nas tags. Veja abaixo um exemplo simples de C #:

System.Web.UI.HtmlControls.HtmlGenericControl htmlDiv = new System.Web.UI.HtmlControls.HtmlGenericControl("div");
htmlDiv.InnerHtml = htmlString;
String plainText = htmlDiv.InnerText;

Eu escrevi um método bastante rápido em c # que supera o Regex. Está hospedado em um artigo no CodeProject.

Suas vantagens são, entre melhor desempenho, a capacidade de substituir entidades HTML nomeadas e numeradas (aquelas como &e&203; ) e substituir blocos de comentários e muito mais.

Por favor, leia o artigo relacionado no CodeProject .

Obrigado.

Para aqueles que não podem usar o HtmlAgilityPack, o leitor XML do .NETs é uma opção. Isso pode falhar em HTML bem formatado, portanto, sempre adicione uma captura com o regx como um backup. Observe que isso NÃO é rápido, mas fornece uma boa oportunidade para a etapa da velha escola na depuração.

public static string RemoveHTMLTags(string content)
    {
        var cleaned = string.Empty;
        try
        {
            StringBuilder textOnly = new StringBuilder();
            using (var reader = XmlNodeReader.Create(new System.IO.StringReader("<xml>" + content + "</xml>")))
            {
                while (reader.Read())
                {
                    if (reader.NodeType == XmlNodeType.Text)
                        textOnly.Append(reader.ReadContentAsString());
                }
            }
            cleaned = textOnly.ToString();
        }
        catch
        {
            //A tag is probably not closed. fallback to regex string clean.
            string textOnly = string.Empty;
            Regex tagRemove = new Regex(@"<[^>]*(>|$)");
            Regex compressSpaces = new Regex(@"[\s\r\n]+");
            textOnly = tagRemove.Replace(content, string.Empty);
            textOnly = compressSpaces.Replace(textOnly, " ");
            cleaned = textOnly;
        }

        return cleaned;
    }

string result = Regex.Replace(anytext, @"<(.|\n)*?>", string.Empty);

Para aqueles que estão se queixando de que a solução de Michael Tiptop não está funcionando, aqui está a maneira .Net4 + de fazer isso:

public static string StripTags(this string markup)
{
    try
    {
        StringReader sr = new StringReader(markup);
        XPathDocument doc;
        using (XmlReader xr = XmlReader.Create(sr,
                           new XmlReaderSettings()
                           {
                               ConformanceLevel = ConformanceLevel.Fragment
                               // for multiple roots
                           }))
        {
            doc = new XPathDocument(xr);
        }

        return doc.CreateNavigator().Value; // .Value is similar to .InnerText of  
                                           //  XmlDocument or JavaScript's innerText
    }
    catch
    {
        return string.Empty;
    }
}

using System.Text.RegularExpressions;

string str = Regex.Replace(HttpUtility.HtmlDecode(HTMLString), "<.*?>", string.Empty);

Analisei as soluções baseadas em Regex sugeridas aqui e elas não me enchem de confiança, exceto nos casos mais triviais. Um colchete angular em um atributo é tudo o que seria necessário para quebrar, e muito menos HTML malformado. E o que dizer de entidades como& ? Se você deseja converter HTML em texto sem formatação, também é necessário decodificar entidades.

Então, proponho o método abaixo.

Usando HtmlAgilityPack , esse método de extensão remove eficientemente todas as tags HTML de um fragmento html. Também decodifica entidades HTML como &. Retorna apenas os itens de texto internos, com uma nova linha entre cada item de texto.

public static string RemoveHtmlTags(this string html)
{
        if (String.IsNullOrEmpty(html))
            return html;

        var doc = new HtmlAgilityPack.HtmlDocument();
        doc.LoadHtml(html);

        if (doc.DocumentNode == null || doc.DocumentNode.ChildNodes == null)
        {
            return WebUtility.HtmlDecode(html);
        }

        var sb = new StringBuilder();

        var i = 0;

        foreach (var node in doc.DocumentNode.ChildNodes)
        {
            var text = node.InnerText.SafeTrim();

            if (!String.IsNullOrEmpty(text))
            {
                sb.Append(text);

                if (i < doc.DocumentNode.ChildNodes.Count - 1)
                {
                    sb.Append(Environment.NewLine);
                }
            }

            i++;
        }

        var result = sb.ToString();

        return WebUtility.HtmlDecode(result);
}

public static string SafeTrim(this string str)
{
    if (str == null)
        return null;

    return str.Trim();
}

Se você for realmente sério, você iria querer ignorar o conteúdo das etiquetas de certa HTML também ( <script>, <style>, <svg>, <head>,<object> vêm à mente!) Porque eles provavelmente não contêm conteúdo legível, no sentido de que são depois. O que você faz lá depende das suas circunstâncias e até onde você deseja ir, mas usar o HtmlAgilityPack seria bastante trivial para colocar as tags selecionadas na lista de permissões ou na lista negra.

Se você estiver renderizando o conteúdo de volta para uma página HTML, certifique-se de entender a vulnerabilidade XSS e como evitá-la - ou seja, sempre codifique qualquer texto inserido pelo usuário que seja renderizado novamente em uma página HTML ( >torna-se >etc).

Para o segundo parâmetro, ou seja, mantenha algumas tags, você pode precisar de um código como este usando HTMLagilityPack:

public string StripTags(HtmlNode documentNode, IList keepTags)
{
    var result = new StringBuilder();
        foreach (var childNode in documentNode.ChildNodes)
        {
            if (childNode.Name.ToLower() == "#text")
            {
                result.Append(childNode.InnerText);
            }
            else
            {
                if (!keepTags.Contains(childNode.Name.ToLower()))
                {
                    result.Append(StripTags(childNode, keepTags));
                }
                else
                {
                    result.Append(childNode.OuterHtml.Replace(childNode.InnerHtml, StripTags(childNode, keepTags)));
                }
            }
        }
        return result.ToString();
    }

Mais explicações nesta página: http://nalgorithm.com/2015/11/20/strip-html-tags-of-an-html-in-c-strip_html-php-equivalent/

Você também pode fazer isso com o AngleSharp, que é uma alternativa ao HtmlAgilityPack (não que o HAP seja ruim). É mais fácil usar do que o HAP para obter o texto de uma fonte HTML.

var parser = new HtmlParser();
var htmlDocument = parser.ParseDocument(source);
var text = htmlDocument.Body.Text();

Você pode dar uma olhada na seção de recursos principais , na qual eles afirmam ser "melhores" que o HAP. Eu acho que, na maior parte, provavelmente é um exagero para a pergunta atual, mas ainda assim, é uma alternativa interessante.

Basta usar string.StripHTML();