Devo usare HttpUtility.HtmlEncode o scrivere un metodo di estensione?
Pro per l'utilizzo di HttpUtility.HtmlEncode è che altri sviluppatori possono vedere e riconoscere immediatamente ciò che sta facendo.
Pro per l'utilizzo di un metodo di estensione è che è meno codice da scrivere ovunque e meno rumore.
Quindi suppongo di chiedere una leggibilità ovvia rispetto al codice più teso.
Supponendo che chiamerai HttpUtility.HtmlEncoded() dal tuo metodo di estensione (altrimenti è un no-no) e che utilizzerai un nome significativo per il tuo metodo (altrimenti ti limiterai a rendere il codice meno chiaro). Dato:
string someText = "This is some text";
Confrontiamo:
string htmlEncoded1 = someText.ToHtmlEncodedString();
string htmlEncoded2 = HttpUtility.HtmlEncode(someText);
Onestamente non vedo grandi miglioramenti. Ora introduciamo la caratteristica statica C # 6:
string htmlEncoded1 = someText.ToHtmlEncodedString();
string htmlEncoded2 = HtmlEncode(someText);
Penso sia chiaro quale sia migliore . Nota anche che HttpUtility.HtmlEncode() ha tre metodi in overload e di solito considero una pessima pratica quella di inquinare object con metodi di estensione inutili.
Si noti che "... meno codice per scrivere ..." non è sempre e senza dubbio migliore . Le conversioni di stringhe sono importanti e critiche (sia per le prestazioni che per la sicurezza). Se denomini il tuo metodo ToHtmlString() ma - con l'aiuto di Intellisense - scrivi ToString() potresti avere un grosso bug latente nel tuo codice che potrebbe passare inosservato in una sessione di revisione del codice.
Puoi avere il meglio di entrambi i mondi sovrascrivendo il comportamento HtmlEncode. Questo si ottiene sovrascrivendo la classe HttpEncoder in questo modo:
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Web;
using System.Web.Util;
using System.Text;
using System.IO;
/// <summary>
/// Summary description for CustomHttpEncoder
/// </summary>
public class CustomHttpEncoder : HttpEncoder
{
//
// TODO: Add constructor logic here
//
public CustomHttpEncoder()
{
}
protected override void HtmlEncode(string value, TextWriter output)
{
if (value != null) {
MyHtmlEncode(value, output);
}
}
protected override void HtmlAttributeEncode(string value, TextWriter output)
{
if (value != null) {
MyHtmlEncode(value, output);
}
}
private void MyHtmlEncode(string value, TextWriter output)
{
if (value != null) {
string encodedValue = "";
for (int i = 0; i <= value.Length - 1; i++) {
byte[] asciiVal = Encoding.ASCII.GetBytes(value.Substring(i, 1));
encodedValue += "&#" + asciiVal(0).ToString + ";";
}
output.Write(encodedValue);
}
}
}
Dopo questo, devi solo fare riferimento alla tua classe di override in Web.config:
<system.web>
<httpRuntime encoderType="CustomHttpEncoder" />
La classe Encoder fornita qui è ciò che ho usato sui miei progetti al lavoro. La nostra suite di pentesting è MOLTO esigente per quanto riguarda la codifica dell'output, quindi la classe sopra semplicemente codifica ogni carattere nella stringa che gli viene assegnata. Sentiti libero di rimuovere il cappello di lamina e basta che MyHtmlEncode () codifichi solo determinati caratteri.
Il miglior consiglio è di non usare HttpUtility.HtmlEncode. Il problema è che questo restituisce una stringa, il che significa che il sistema di tipi non può intercettare errori di codifica.
La soluzione migliore è avere una struttura HTML che rappresenti rigorosamente e solo l'HTML e quindi utilizzarne le istanze per rappresentare l'HTML, piuttosto che le stringhe. Quindi il compilatore può assicurarti che non mismatch HTML e testo.
Idealmente, dovresti usare anche un'altra struttura per il testo semplice.