Serializzazione di un oggetto come XML UTF-8 in .NET

Eliminazione corretta degli oggetti rimossa per brevità, ma sono scioccato se questo è il modo più semplice per codificare un oggetto come UTF-8 in memoria. Deve esserci un modo più semplice, no?

var serializer = new XmlSerializer(typeof(SomeSerializableObject));

var memoryStream = new MemoryStream();
var streamWriter = new StreamWriter(memoryStream, System.Text.Encoding.UTF8);

serializer.Serialize(streamWriter, entry);

memoryStream.Seek(0, SeekOrigin.Begin);
var streamReader = new StreamReader(memoryStream, System.Text.Encoding.UTF8);
var utf8EncodedXml = streamReader.ReadToEnd();

Il tuo codice non ottiene l'UTF-8 in memoria mentre lo leggi di nuovo in una stringa, quindi non è più in UTF-8, ma di nuovo in UTF-16 (anche se idealmente è meglio considerare le stringhe a un livello più alto di qualsiasi codifica, tranne quando forzato a farlo).

Per ottenere gli ottetti UTF-8 effettivi potresti usare:

var serializer = new XmlSerializer(typeof(SomeSerializableObject));

var memoryStream = new MemoryStream();
var streamWriter = new StreamWriter(memoryStream, System.Text.Encoding.UTF8);

serializer.Serialize(streamWriter, entry);

byte[] utf8EncodedXml = memoryStream.ToArray();

Ho tralasciato lo stesso smaltimento che hai lasciato. Preferisco leggermente quanto segue (con lo smaltimento normale lasciato in):

var serializer = new XmlSerializer(typeof(SomeSerializableObject));
using(var memStm = new MemoryStream())
using(var  xw = XmlWriter.Create(memStm))
{
  serializer.Serialize(xw, entry);
  var utf8 = memStm.ToArray();
}

Che è più o meno la stessa quantità di complessità, ma mostra che in ogni fase c'è una scelta ragionevole per fare qualcos'altro, la più urgente delle quali è serializzare in un luogo diverso dalla memoria, come un file, TCP / IP stream, database, ecc. Tutto sommato, non è così prolisso.

No, puoi usare a StringWriterper sbarazzarti dell'intermedio MemoryStream. Tuttavia, per forzarlo in XML è necessario utilizzare un StringWriterche sovrascrive la Encodingproprietà:

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

O se non stai ancora usando C # 6:

public class Utf8StringWriter : StringWriter
{
    public override Encoding Encoding { get { return Encoding.UTF8; } }
}

Poi:

var serializer = new XmlSerializer(typeof(SomeSerializableObject));
string utf8;
using (StringWriter writer = new Utf8StringWriter())
{
    serializer.Serialize(writer, entry);
    utf8 = writer.ToString();
}

Ovviamente puoi trasformare Utf8StringWriterin una classe più generale che accetta qualsiasi codifica nel suo costruttore - ma nella mia esperienza UTF-8 è di gran lunga la codifica "personalizzata" più comunemente richiesta per un StringWriter:)

Ora, come dice Jon Hanna, questo sarà ancora UTF-16 internamente, ma presumibilmente lo passerai a qualcos'altro ad un certo punto, per convertirlo in dati binari ... a quel punto puoi usare la stringa sopra, convertitelo in byte UTF-8 e tutto andrà bene, perché la dichiarazione XML specificherà "utf-8" come codifica.

EDIT: un esempio breve ma completo per mostrare questo funzionamento:

using System;
using System.Text;
using System.IO;
using System.Xml.Serialization;

public class Test
{    
    public int X { get; set; }

    static void Main()
    {
        Test t = new Test();
        var serializer = new XmlSerializer(typeof(Test));
        string utf8;
        using (StringWriter writer = new Utf8StringWriter())
        {
            serializer.Serialize(writer, t);
            utf8 = writer.ToString();
        }
        Console.WriteLine(utf8);
    }


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

Risultato:

<?xml version="1.0" encoding="utf-8"?>
<Test xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <X>0</X>
</Test>

Notare la codifica dichiarata di "utf-8" che è quello che volevamo, credo.

Ottima risposta usando l'ereditarietà, ricorda solo di sovrascrivere l'inizializzatore

public class Utf8StringWriter : StringWriter
{
    public Utf8StringWriter(StringBuilder sb) : base (sb)
    {
    }
    public override Encoding Encoding { get { return Encoding.UTF8; } }
}

Ho trovato questo post del blog che spiega molto bene il problema e definisce alcune soluzioni diverse:

(collegamento morto rimosso)

Ho deciso che il modo migliore per farlo è omettere completamente la dichiarazione XML quando è in memoria. In realtà è UTF-16 a quel punto comunque, ma la dichiarazione XML non sembra significativa finché non è stata scritta in un file con una particolare codifica; e anche allora la dichiarazione non è richiesta. Almeno non sembra rompere la deserializzazione.

Come menzionato da @Jon Hanna, questo può essere fatto con un XmlWriter creato in questo modo:

XmlWriter writer = XmlWriter.Create (output, new XmlWriterSettings() { OmitXmlDeclaration = true });