Utilizzo di StringWriter per la serializzazione XML

Attualmente sto cercando un modo semplice per serializzare gli oggetti (in C # 3).

Ho cercato su Google alcuni esempi e ho trovato qualcosa come:

MemoryStream memoryStream = new MemoryStream ( );
XmlSerializer xs = new XmlSerializer ( typeof ( MyObject) );
XmlTextWriter xmlTextWriter = new XmlTextWriter ( memoryStream, Encoding.UTF8 );
xs.Serialize ( xmlTextWriter, myObject);
string result = Encoding.UTF8.GetString(memoryStream .ToArray());

Dopo aver letto questa domanda mi sono chiesto, perché non usare StringWriter? Sembra molto più facile.

XmlSerializer ser = new XmlSerializer(typeof(MyObject));
StringWriter writer = new StringWriter();
ser.Serialize(writer, myObject);
serializedValue = writer.ToString();

Un altro problema era che il primo esempio di XML generato non potevo semplicemente scrivere in una colonna XML di SQL Server 2005 DB.

La prima domanda è: c'è un motivo per cui non dovrei usare StringWriter per serializzare un oggetto quando ne ho bisogno come stringa in seguito? Non ho mai trovato un risultato utilizzando StringWriter quando cercavo su Google.

Il secondo è, ovviamente: se non dovessi farlo con StringWriter (per qualsiasi motivo), quale sarebbe un modo buono e corretto?

Aggiunta:

Come già menzionato da entrambe le risposte, approfondirò il problema da XML a DB.

Durante la scrittura nel database ho ottenuto la seguente eccezione:

System.Data.SqlClient.SqlException: analisi XML: riga 1, carattere 38, impossibile cambiare la codifica

Per stringa

<?xml version="1.0" encoding="utf-8"?><test/>

Ho preso la stringa creata da XmlTextWriter e l'ho inserita come xml. Questo non ha funzionato (nemmeno con l'inserimento manuale nel DB).

In seguito ho provato l'inserimento manuale (semplicemente scrivendo INSERT INTO ...) con encoding = "utf-16" che non è riuscito. La rimozione della codifica ha funzionato completamente quindi. Dopo quel risultato sono tornato al codice StringWriter e voilà - ha funzionato.

Problema: non capisco davvero perché.

a Christian Hayter: Con quei test non sono sicuro di dover usare utf-16 per scrivere sul DB. L'impostazione della codifica su UTF-16 (nel tag xml) non funzionerebbe allora?

<TL; DR> Il problema è piuttosto semplice, in realtà: non stai facendo corrispondere la codifica dichiarata (nella dichiarazione XML) con il tipo di dati del parametro di input. Se hai aggiunto manualmente <?xml version="1.0" encoding="utf-8"?><test/>alla stringa, dichiarando SqlParameterdi essere di tipo SqlDbType.Xmlo SqlDbType.NVarCharti darebbe l'errore "impossibile cambiare la codifica". Quindi, durante l'inserimento manuale tramite T-SQL, poiché hai cambiato la codifica dichiarata in utf-16, stai chiaramente inserendo una VARCHARstringa (non preceduta da una "N" maiuscola, quindi una codifica a 8 bit, come UTF-8) e non una NVARCHARstringa (preceduta da una "N" maiuscola, da cui la codifica UTF-16 LE a 16 bit).

La correzione avrebbe dovuto essere semplice come:

1. Nel primo caso, quando si aggiunge la dichiarazione che indica encoding="utf-8": semplicemente non aggiungere la dichiarazione XML.
2. Nel secondo caso, quando si aggiunge la dichiarazione che dichiara encoding="utf-16": o
   1. semplicemente non aggiungere la dichiarazione XML, OR
   2. aggiungi semplicemente una "N" al tipo di parametro di input: SqlDbType.NVarCharinvece di SqlDbType.VarChar:-) (o eventualmente passa anche all'uso SqlDbType.Xml)

(La risposta dettagliata è sotto)

Tutte le risposte qui sono troppo complicate e non necessarie (indipendentemente dai 121 e 184 voti positivi per le risposte di Christian e Jon, rispettivamente). Potrebbero fornire codice funzionante, ma nessuno di loro risponde effettivamente alla domanda. Il problema è che nessuno ha capito veramente la domanda, che in ultima analisi riguarda il funzionamento del tipo di dati XML in SQL Server. Niente contro quelle due persone chiaramente intelligenti, ma questa domanda ha poco a che fare con la serializzazione in XML. Il salvataggio dei dati XML in SQL Server è molto più semplice di quanto implicito qui.

Non importa come viene prodotto l'XML purché si seguano le regole su come creare dati XML in SQL Server. Ho una spiegazione più approfondita (incluso un codice di esempio funzionante per illustrare i punti delineati di seguito) in una risposta a questa domanda: come risolvere l'errore "impossibile cambiare la codifica" quando si inserisce XML in SQL Server , ma le basi sono:

1. La dichiarazione XML è facoltativa
2. Il tipo di dati XML memorizza le stringhe sempre come UCS-2 / UTF-16 LE
3. Se il tuo XML è UCS-2 / UTF-16 LE, allora:
   1. passare i dati come NVARCHAR(MAX)o XML/ SqlDbType.NVarChar(maxsize = -1) o SqlDbType.Xml, o se si utilizza una stringa letterale, deve essere preceduta da una "N" maiuscola.
   2. se si specifica la dichiarazione XML, deve essere "UCS-2" o "UTF-16" (nessuna differenza reale qui)
4. Se il tuo XML è codificato a 8 bit (ad es. "UTF-8" / "iso-8859-1" / "Windows-1252"), allora:
   1. è necessario specificare la dichiarazione XML SE la codifica è diversa dalla tabella codici specificata dalle regole di confronto predefinite del database
   2. è necessario passare i dati come VARCHAR(MAX)/ SqlDbType.VarChar(maxsize = -1), oppure se si utilizza una stringa letterale allora deve non essere preceduto da un maiuscola "N".
   3. Qualunque sia la codifica a 8 bit utilizzata, la "codifica" annotata nella dichiarazione XML deve corrispondere alla codifica effettiva dei byte.
   4. La codifica a 8 bit verrà convertita in UTF-16 LE dal tipo di dati XML

Tenendo a mente i punti sopra delineati e dato che le stringhe in .NET sono sempre UTF-16 LE / UCS-2 LE (non c'è differenza tra quelle in termini di codifica), possiamo rispondere alle tue domande:

C'è un motivo per cui non dovrei usare StringWriter per serializzare un oggetto quando ne ho bisogno come stringa in seguito?

No, il tuo StringWritercodice sembra andare bene (almeno non vedo problemi nei miei test limitati usando il 2 ° blocco di codice dalla domanda).

L'impostazione della codifica su UTF-16 (nel tag xml) non funzionerebbe allora?

Non è necessario fornire la dichiarazione XML. Quando manca, si presume che la codifica sia UTF-16 LE se si passa la stringa in SQL Server come NVARCHAR(ie SqlDbType.NVarChar) o XML(ie SqlDbType.Xml). Si presume che la codifica sia la Code Page predefinita a 8 bit se passata come VARCHAR(cioè SqlDbType.VarChar). Se hai caratteri ASCII non standard (cioè valori 128 e superiori) e stai passando come VARCHAR, allora probabilmente vedrai "?" per i caratteri BMP e "??" per i caratteri supplementari come SQL Server convertirà la stringa UTF-16 da .NET in una stringa a 8 bit della pagina codici del database corrente prima di riconvertirla in UTF-16 / UCS-2. Ma non dovresti ricevere alcun errore.

D'altra parte, se si specifica la dichiarazione XML, è necessario passare a SQL Server utilizzando il tipo di dati corrispondente a 8 bit o 16 bit. Quindi, se hai una dichiarazione che afferma che la codifica è UCS-2 o UTF-16, devi passare come SqlDbType.NVarCharo SqlDbType.Xml. Oppure, se si dispone di una dichiarazione attestante che la codifica è una delle opzioni a 8 bit (cioè UTF-8, Windows-1252, iso-8859-1, ecc), allora si deve passare come SqlDbType.VarChar. La mancata corrispondenza della codifica dichiarata con il tipo di dati SQL Server corretto a 8 o 16 bit comporterà l'errore "impossibile cambiare la codifica" che stavi ricevendo.

Ad esempio, utilizzando il StringWritercodice di serializzazione basato sul tuo , ho semplicemente stampato la stringa risultante dell'XML e l'ho usata in SSMS. Come puoi vedere di seguito, la dichiarazione XML è inclusa (perché StringWriternon ha un'opzione per OmitXmlDeclarationapprezzare XmlWriter), il che non pone problemi fintanto che passi la stringa come il tipo di dati corretto di SQL Server:

-- Upper-case "N" prefix == NVARCHAR, hence no error:
DECLARE @Xml XML = N'<?xml version="1.0" encoding="utf-16"?>
<string>Test ሴ😸</string>';
SELECT @Xml;
-- <string>Test ሴ😸</string>

Come puoi vedere, gestisce anche i caratteri oltre lo standard ASCII, dato che ሴè BMP Code Point U + 1234, ed 😸è Supplementary Character Code Point U + 1F638. Tuttavia, quanto segue:

-- No upper-case "N" prefix on the string literal, hence VARCHAR:
DECLARE @Xml XML = '<?xml version="1.0" encoding="utf-16"?>
<string>Test ሴ😸</string>';

si traduce nel seguente errore:

Msg 9402, Level 16, State 1, Line XXXXX
XML parsing: line 1, character 39, unable to switch the encoding

Ergo, a parte tutte queste spiegazioni, la soluzione completa alla tua domanda originale è:

Stavi chiaramente passando la stringa come SqlDbType.VarChar. Passa a SqlDbType.NVarChare funzionerà senza dover eseguire il passaggio aggiuntivo di rimozione della dichiarazione XML. Ciò è preferibile rispetto a mantenere SqlDbType.VarChare rimuovere la dichiarazione XML perché questa soluzione impedirà la perdita di dati quando l'XML include caratteri ASCII non standard. Per esempio:

-- No upper-case "N" prefix on the string literal == VARCHAR, and no XML declaration:
DECLARE @Xml2 XML = '<string>Test ሴ😸</string>';
SELECT @Xml2;
-- <string>Test ???</string>

Come puoi vedere, questa volta non ci sono errori, ma ora c'è una perdita di dati 🙀.

Un problema StringWriterè che per impostazione predefinita non ti consente di impostare la codifica che pubblicizza , quindi puoi finire con un documento XML che pubblicizza la sua codifica come UTF-16, il che significa che devi codificarlo come UTF-16 se lo desideri scriverlo su un file. Ho una piccola classe per aiutare con questo però:

public sealed class StringWriterWithEncoding : StringWriter
{
    public override Encoding Encoding { get; }

    public StringWriterWithEncoding (Encoding encoding)
    {
        Encoding = encoding;
    }    
}

O se hai solo bisogno di UTF-8 (che è tutto ciò di cui ho spesso bisogno):

public sealed class Utf8StringWriter : StringWriter
{
    public override Encoding Encoding => Encoding.UTF8;
}

Per quanto riguarda il motivo per cui non è stato possibile salvare il tuo XML nel database, dovrai fornirci maggiori dettagli su cosa è successo quando hai provato, se vuoi che siamo in grado di diagnosticare / aggiustarlo.

Quando si serializza un documento XML in una stringa .NET, la codifica deve essere impostata su UTF-16. Le stringhe sono archiviate internamente come UTF-16, quindi questa è l'unica codifica che ha senso. Se desideri memorizzare i dati in una codifica diversa, utilizza invece un array di byte.

SQL Server funziona secondo un principio simile; qualsiasi stringa passata in una xmlcolonna deve essere codificata come UTF-16. SQL Server rifiuterà qualsiasi stringa in cui la dichiarazione XML non specifica UTF-16. Se la dichiarazione XML non è presente, lo standard XML richiede che sia predefinita su UTF-8, quindi SQL Server rifiuterà anche quella.

Tenendo presente questo, ecco alcuni metodi di utilità per eseguire la conversione.

public static string Serialize<T>(T value) {

    if(value == null) {
        return null;
    }

    XmlSerializer serializer = new XmlSerializer(typeof(T));

    XmlWriterSettings settings = new XmlWriterSettings()
    {
        Encoding = new UnicodeEncoding(false, false), // no BOM in a .NET string
        Indent = false,
        OmitXmlDeclaration = false
    };

    using(StringWriter textWriter = new StringWriter()) {
        using(XmlWriter xmlWriter = XmlWriter.Create(textWriter, settings)) {
            serializer.Serialize(xmlWriter, value);
        }
        return textWriter.ToString();
    }
}

public static T Deserialize<T>(string xml) {

    if(string.IsNullOrEmpty(xml)) {
        return default(T);
    }

    XmlSerializer serializer = new XmlSerializer(typeof(T));

    XmlReaderSettings settings = new XmlReaderSettings();
    // No settings need modifying here

    using(StringReader textReader = new StringReader(xml)) {
        using(XmlReader xmlReader = XmlReader.Create(textReader, settings)) {
            return (T) serializer.Deserialize(xmlReader);
        }
    }
}

Prima di tutto, fai attenzione a trovare vecchi esempi. Ne hai trovato uno che utilizza XmlTextWriter, che è deprecato a partire da .NET 2.0. XmlWriter.Createdovrebbe essere usato invece.

Ecco un esempio di serializzazione di un oggetto in una colonna XML:

public void SerializeToXmlColumn(object obj)
{
    using (var outputStream = new MemoryStream())
    {
        using (var writer = XmlWriter.Create(outputStream))
        {
            var serializer = new XmlSerializer(obj.GetType());
            serializer.Serialize(writer, obj);
        }

        outputStream.Position = 0;
        using (var conn = new SqlConnection(Settings.Default.ConnectionString))
        {
            conn.Open();

            const string INSERT_COMMAND = @"INSERT INTO XmlStore (Data) VALUES (@Data)";
            using (var cmd = new SqlCommand(INSERT_COMMAND, conn))
            {
                using (var reader = XmlReader.Create(outputStream))
                {
                    var xml = new SqlXml(reader);

                    cmd.Parameters.Clear();
                    cmd.Parameters.AddWithValue("@Data", xml);
                    cmd.ExecuteNonQuery();
                }
            }
        }
    }
}

public static T DeserializeFromXml<T>(string xml)
{
    T result;
    XmlSerializerFactory serializerFactory = new XmlSerializerFactory();
    XmlSerializer serializer =serializerFactory.CreateSerializer(typeof(T));

    using (StringReader sr3 = new StringReader(xml))
    {
        XmlReaderSettings settings = new XmlReaderSettings()
        {
            CheckCharacters = false // default value is true;
        };

        using (XmlReader xr3 = XmlTextReader.Create(sr3, settings))
        {
            result = (T)serializer.Deserialize(xr3);
        }
    }

    return result;
}

Potrebbe essere stato trattato altrove, ma la semplice modifica della riga di codifica del sorgente XML in "utf-16" consente di inserire l'XML in un tipo di dati xml di SQL Server.

using (DataSetTableAdapters.SQSTableAdapter tbl_SQS = new DataSetTableAdapters.SQSTableAdapter())
{
    try
    {
        bodyXML = @"<?xml version="1.0" encoding="UTF-8" standalone="yes"?><test></test>";
        bodyXMLutf16 = bodyXML.Replace("UTF-8", "UTF-16");
        tbl_SQS.Insert(messageID, receiptHandle, md5OfBody, bodyXMLutf16, sourceType);
    }
    catch (System.Data.SqlClient.SqlException ex)
    {
        Console.WriteLine(ex.Message);
        Console.ReadLine();
    }
}

Il risultato è che tutto il testo XML viene inserito nel campo del tipo di dati "xml" ma la riga "intestazione" viene rimossa. Quello che vedi nel record risultante è giusto

<test></test>

L'uso del metodo di serializzazione descritto nella voce "Con risposta" è un modo per includere l'intestazione originale nel campo di destinazione, ma il risultato è che il testo XML rimanente è racchiuso in un <string></string>tag XML .

L'adattatore tabella nel codice è una classe creata automaticamente utilizzando la procedura guidata Aggiungi nuova origine dati: di Visual Studio 2013. I cinque parametri del metodo di inserimento si associano ai campi in una tabella di SQL Server.