Utilizzo di HtmlTextWriter per il rendering dei controlli del server?

Question

Sto scrivendo il metodo RenderContents() del mio controllo server ASP.NET. Il metodo utilizza un oggetto HtmlTextWriter per eseguire il rendering del contenuto di output. Per il controllo che sto scrivendo, l'uso dei metodi di StringBuilder sembra che richiederà molte righe di codice per aprire e chiudere ogni tag e aggiungere tutti gli attributi allo stream. Alla fine mi sento come se stessi per finire con un codice che è molto più lungo di quanto debba essere.

Pensavo che se avessi usato una classe concatenabile come <=>, il mio codice sarebbe stato molto più pulito da leggere e più facile da scrivere.

Quello che mi chiedevo era: c'è qualche motivo per usare l'oggetto <=> per rendere l'intero contenuto del mio controllo? A parte i controlli di sicurezza (presumo) includa per assicurarsi di non scrivere tag nell'ordine sbagliato o creare markup non validi, non vedo un motivo.

Sembra che sarebbe più semplice fare qualcosa del genere:

protected override void RenderContents(HtmlTextWriter output)
{
    StringBuilder s = new StringBuilder();
    s.Append("lots")
     .Append("of")
     .Append("strings");

    output.BeginRender();
    output.Write(s.ToString());
    output.EndRender();
}

C'è qualche motivo per cui questa sarebbe una cattiva idea?

Aggiorna
In risposta alla la risposta di Mehrdad Afshari :
 Non ho pensato molto ai requisiti di memoria di avere un'istanza <=> separata. Che ne dici di creare un wrapper per HtmlTextWriter in modo che possa essere incatenato in modo da non creare una stringa aggiuntiva.

public class ChainedHtmlTextWriter
{
    private HtmlTextWriter _W;
    public ChainedHtmlTextWriter(HtmlTextWriter writer)
    {
        _W = writer;
    }

    public ChainedHtmlTextWriter Write<T>(T value) 
    { 
        _W.Write(value); 
        return this; 
    }

    public ChainedHtmlTextWriter WriteLine<T>(T value)
    {
        _W.WriteLine(value);
        return this;
    }
}

Answer 1

Lavoro su un'applicazione in cui gli sviluppatori hanno seguito l'orribile percorso che stai esplorando. Questo fa pensare ai giorni in cui dovevi scrivere le tue dll ISAPI che sputavano codice html. È un mal di testa costante in cui lavorare. Se il tuo codice è per lo più stringhe, allora qualcosa non va.

La maggior parte del codice di questo tipo che ho modificato istanzia oggetti server, configura le loro proprietà come desiderato e poi dico loro a .RenderControl (writer). Questo rende il codice molto più facile da leggere e lavorare. Se il sovraccarico comporta un calo delle prestazioni, sono disposto ad accettarlo (in effetti, l'applicazione generalmente funziona più velocemente dopo aver apportato le mie modifiche, quindi aneddoticamente non è così, ma non ho profilato il mio codice).

Un semplice svantaggio di codificare le tue cose in stringhe è quando cambiano gli standard HTML. Il codice su cui lavoro è stato scritto nel 04/05 e da allora & Lt; BR & Gt; è diventato < br / > e i tag html maiuscoli non sono più kasher, ecc. Se avessero usato i controlli server, quei controlli server avrebbero cambiato il loro html emesso senza che noi dovessimo fare nulla. Questo è solo un semplice esempio.

EDIT: Oh, e tra l'altro, BeginRender ed EndRender non hanno alcuna implementazione. Sono segnaposto da sovrascrivere e fornire funzionalità personalizzate in una classe derivata da HtmlTextWriter.

EDIT2: a volte è un po 'oneroso sempre usare i controlli del server, come per contenitori e cose. Farei un sacco di .Controls.Add () e quindi rendere il contenitore più tardi. Quindi a volte lo faccio:

writer.AddAttribute(HtmlTextWriterAttribute.Class, "myContainerClass");
writer.RenderBeginTag(HtmlTextWriterTag.Div);
// do some stuff, .RenderControl on some other controls, etc.
writer.RenderEndTag();

Come accennato, questo renderà html corretto anche se l'html di un div cambi in futuro, perché non ho stringhe codificate.

Answer 2

Dal punto di vista delle prestazioni, ciò richiederà l'esecuzione di più copie di stringhe. HtmlTextWriter scrive direttamente nel buffer di output. StringBuilder d'altra parte, ha il suo buffer. Quando si chiama ToString su output.Write, è necessario creare una nuova stringa e quindi verrà scritta nel buffer di output entro <=>. Richiede molto più lavoro da fare.

Answer 3

Non credo che dovresti chiamare BeginRender / EndRender, fatto fatto dalla pagina.

Non riesco a vedere come l'uso del generatore di stringhe risparmierebbe alcun lavoro rispetto ai metodi propri di HtmlTextWriters.