Qual è il modo migliore per creare HTML nel codice C #? [chiuso]

Sono convinto che il markup debba rimanere nel markup e non nel codice sottostante.

Sono arrivato a una situazione in cui penso sia accettabile costruire l'HTML nel codice dietro. Mi piacerebbe avere un certo consenso su quali siano o dovrebbero essere le migliori pratiche.

Quando è accettabile creare html nel codice dietro? Qual è il metodo migliore per creare questo HTML? (esempio: Stringhe, StringBuilder, HTMLWriter, ecc.)

L'uso di qualcosa come Razor non è applicabile qui? Perché se stai facendo molta generazione di html usando un motore di visualizzazione puoi renderlo molto più semplice. È stato inoltre creato per essere utilizzato al di fuori di ASP.NET.

Tuttavia a volte non è quello che ti serve. Hai mai considerato di utilizzare la classe TagBuilder che fa parte di .net (mvc)? C'è anche HtmlWriter in System.Web.UI (per i moduli web). Consiglierei uno di questi se stai facendo Controlso Html Helpers.

Vorrei utilizzare l' Html Agility Pack per assemblare HTML e quindi scriverlo in un file di testo.

Molte ore di lavoro sono andate nel rendere l'Html Agility Pack robusto e compatibile con HTML.

Penso che includa anche un'applicazione di esempio che genera HTML.

Dalla home page:

Esempi di applicazioni:

Correzione o generazione della pagina. È possibile correggere una pagina nel modo desiderato, modificare il DOM, aggiungere nodi, copiare nodi, ebbene ... nominarlo.

Vorrei usare htmltags per creare HTML.

Esempio:

var tag = new HtmlTag("span")
    .Text("Hello & Goodbye")
    .AddClass("important")
    .Attr("title", "Greetings")

E poi CSQuery se voglio analizzare HTML

Esempio:

dom.Select("div > span")
    .Eq(1)
    .Text("Change the text content of the 2nd span child of each div");

Esistono, naturalmente, librerie là fuori, come HTML Agility Pack che può aiutarti in questi sforzi.

Se davvero non vuoi usare una libreria esistente e desideri un codice semplice e dettagliato, mi piace l'idea di sottrarre alcuni comportamenti come indicato in una risposta precedente. Mi piace anche l'idea di utilizzare un StringBuilder sottostante, al contrario di una stringa per un paio di motivi:

1. Le stringhe sono meno efficienti del generatore di stringhe
2. StringBuilder è una struttura di dati indicizzabile,

Se non avessi bisogno di un motore HTML progettato su vasta scala, creerei un'interfaccia semplice e intuitiva

AddLineBreak();
AddSimpleTag(string tagName);
AddSimpleTagAt(string tagName, string content, int index);
Output();

Se finisci per usare solo stringhe, non dimenticare di sfuggire a tutti i caratteri riservati HTML nei dati di output.

&    &
>    >
<    &lt;
"    &quot;
'    &apos;

Consiglio comunque di utilizzare una classe o una libreria HTML-compatibile invece di lavorare direttamente con le stringhe. HTMLWriter sembra un buon inizio.

Quasi due anni dopo il post originale, ecco una soluzione che ha funzionato bene per me. Nel documento di destinazione inserisco quanto segue:

<table>    
    <%:theHtmlTableMomToldYouAbout() %>    //# Where I want my rows of table data to go
</table>

la funzione chiamata è simile al seguente:

    public HtmlString theHtmlTableMomToldYouAbout()
    {
        string content = "";
        HtmlString theEnvelopePlease = null;

        for (int i = 0; i < 5; i++)
        {
            content = content + "<tr><td>The Number Is: " + i + "</td></tr>";
        }
        theEnvelopePlease = new HtmlString(content);
        return theEnvelopePlease;      
    }

E l'output risultante nel browser è come previsto:
Il numero è: 0
Il numero è: 1
Il numero è: 2
Il numero è: 3
Il numero è: 4

Quando vado a visualizzare la fonte trovo quanto segue:

<table>
    <tr><td>The Number Is: 0</td></tr>
    <tr><td>The Number Is: 1</td></tr>
    <tr><td>The Number Is: 2</td></tr>
    <tr><td>The Number Is: 3</td></tr>
    <tr><td>The Number Is: 4</td></tr>
</table>

INFIAMMA!

var html = "";
html += "<table class='colorful'>";
foreach(var item in collection) {
     html += "<tr>";
     html += "<td class='boldCell'>" + item.PropWhatever + "</td>";
     // more cells here as needed
     html += "</tr>";
}
html += "</table>";
placeholder1.InnerHtml = html;

Probabilmente verrò ridimensionato per questo, ma come ex designer che ha dovuto modificare l'HTML nel codice prima di sapere davvero molto su .NET, il codice sopra era molto più facile da capire rispetto ai metodi che astraggono la creazione di HTML. Se pensi che un designer potrebbe mai dover modificare il tuo HTML, usa stringhe semplici come questa.

Qualcosa che vedo perdere molti sviluppatori quando scrivono HTML nel codice è che in HTML sono consentite virgolette singole o doppie per gli attributi. Quindi, invece di sfuggire a tutte le virgolette nel codice (che sembra strano per i non iniziati), usa solo virgolette singole per le virgole html all'interno delle tue stringhe.

FINI. Tutti voi che odiate concatenare le corde stanno facendo crollare il mio rappresentante. Ecco il modo "corretto" per farlo senza concatenazione di stringhe, ma sono convinto che qualsiasi pagina normale con tabelle normali non presenterà alcun problema di prestazioni al di fuori di una ridicola scala simile a Google:

var sb = new System.Text.StringBuilder();
sb.Append("<table class='colorful'>");
foreach (var item in collection)
{
     sb.Append("<tr>");
     sb.Append("<td class='boldCell'>" + item.PropWhatever + "</td>");
     // more cells here as needed
     sb.Append("</tr>");
}
sb.Append("</table>");
placeholder1.InnerHtml = sb.ToString();