Usando StringWriter para la serialización XML

Actualmente estoy buscando una forma fácil de serializar objetos (en C # 3).

Busqué en Google algunos ejemplos y se me ocurrió algo como:

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());

Después de leer esta pregunta, me pregunté, ¿por qué no usar StringWriter? Parece mucho más fácil.

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

Otro problema fue que el primer ejemplo generó XML que no podía simplemente escribir en una columna XML de SQL Server 2005 DB.

La primera pregunta es: ¿Hay alguna razón por la que no debería usar StringWriter para serializar un Objeto cuando lo necesito como cadena después? Nunca encontré un resultado usando StringWriter al buscar en Google.

La segunda es, por supuesto: si no debería hacerlo con StringWriter (por las razones que sean), ¿cuál sería una forma buena y correcta?

Adición:

Como ya se mencionó en ambas respuestas, profundizaré en el problema de XML a DB.

Al escribir en la base de datos, obtuve la siguiente excepción:

System.Data.SqlClient.SqlException: análisis XML: línea 1, carácter 38, no se puede cambiar la codificación

Para cuerda

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

Tomé la cadena creada a partir de XmlTextWriter y simplemente la puse como xml allí. Éste no funcionó (ni con inserción manual en la base de datos).

Luego probé la inserción manual (solo escribiendo INSERT INTO ...) con encoding = "utf-16" que también falló. Eliminar la codificación funcionó totalmente entonces. Después de ese resultado, volví al código StringWriter y listo, funcionó.

Problema: realmente no entiendo por qué.

en Christian Hayter: Con esas pruebas, no estoy seguro de tener que usar utf-16 para escribir en la base de datos. Entonces, ¿no funcionaría configurar la codificación en UTF-16 (en la etiqueta xml)?

<TL; DR> El problema es bastante simple, en realidad: no está haciendo coincidir la codificación declarada (en la declaración XML) con el tipo de datos del parámetro de entrada. Si agregó manualmente <?xml version="1.0" encoding="utf-8"?><test/>a la cadena, entonces declarar SqlParameterque es de tipo SqlDbType.Xmlo SqlDbType.NVarCharle daría el error "No se puede cambiar la codificación". Luego, al insertar manualmente a través de T-SQL, ya que cambió la codificación declarada para serutf-16 , claramente estaba insertando una VARCHARcadena (no con el prefijo "N" en mayúscula, por lo tanto, una codificación de 8 bits, como UTF-8) y no una NVARCHARcadena (con el prefijo "N" en mayúscula, de ahí la codificación UTF-16 LE de 16 bits).

La solución debería haber sido tan simple como:

1. En el primer caso, al agregar la declaración que dice encoding="utf-8": simplemente no agregue la declaración XML.
2. En el segundo caso, al agregar la declaración que indica encoding="utf-16" : o bien
   1. simplemente no agregue la declaración XML, O
   2. simplemente agregue una "N" al tipo de parámetro de entrada: en SqlDbType.NVarCharlugar de SqlDbType.VarChar:-) (o posiblemente incluso cambie a usar SqlDbType.Xml)

(La respuesta detallada está a continuación)

Todas las respuestas aquí son demasiado complicadas e innecesarias (independientemente de los 121 y 184 votos a favor de las respuestas de Christian y Jon, respectivamente). Es posible que proporcionen un código de trabajo, pero ninguno de ellos realmente responde a la pregunta. El problema es que nadie entendió realmente la pregunta, que en última instancia se trata de cómo funciona el tipo de datos XML en SQL Server. Nada en contra de esas dos personas claramente inteligentes, pero esta pregunta tiene poco o nada que ver con la serialización en XML. Guardar datos XML en SQL Server es mucho más fácil de lo que se implica aquí.

Realmente no importa cómo se produce el XML siempre que siga las reglas de cómo crear datos XML en SQL Server. Tengo una explicación más completa (incluido un código de ejemplo de trabajo para ilustrar los puntos que se describen a continuación) en una respuesta a esta pregunta: Cómo resolver el error "no se puede cambiar la codificación" al insertar XML en SQL Server , pero los conceptos básicos son:

1. La declaración XML es opcional
2. El tipo de datos XML almacena cadenas siempre como UCS-2 / UTF-16 LE
3. Si su XML es UCS-2 / UTF-16 LE, entonces:
   1. pasar los datos como NVARCHAR(MAX)o XML/ SqlDbType.NVarChar(maxsize = -1) o SqlDbType.Xml, o si usa una cadena literal, debe tener el prefijo "N" en mayúscula.
   2. si especifica la declaración XML, debe ser "UCS-2" o "UTF-16" (no hay diferencia real aquí)
4. Si su XML está codificado en 8 bits (por ejemplo, "UTF-8" / "iso-8859-1" / "Windows-1252"), entonces:
   1. es necesario especificar la declaración XML SI la codificación es diferente a la página de códigos especificada por la intercalación predeterminada de la base de datos
   2. debe pasar en los datos mientras que VARCHAR(MAX)/ SqlDbType.VarChar(maxsize = -1), o si se utiliza una cadena literal entonces debe no ser prefijado con una mayúscula "N".
   3. Cualquiera que sea la codificación de 8 bits que se utilice, la "codificación" indicada en la declaración XML debe coincidir con la codificación real de los bytes.
   4. La codificación de 8 bits se convertirá en UTF-16 LE por el tipo de datos XML

Teniendo en cuenta los puntos descritos anteriormente, y dado que las cadenas en .NET siempre son UTF-16 LE / UCS-2 LE (no hay diferencia entre ellas en términos de codificación), podemos responder a sus preguntas:

¿Hay alguna razón por la que no debería usar StringWriter para serializar un objeto cuando lo necesito como una cadena después?

No, su StringWritercódigo parece estar bien (al menos no veo problemas en mis pruebas limitadas usando el segundo bloque de código de la pregunta).

Entonces, ¿no funcionaría configurar la codificación en UTF-16 (en la etiqueta xml)?

No es necesario proporcionar la declaración XML. Cuando falta, se asume que la codificación es UTF-16 LE si pasa la cadena a SQL Server como NVARCHAR(ie SqlDbType.NVarChar) o XML(ie SqlDbType.Xml). Se supone que la codificación es la página de códigos de 8 bits predeterminada si se pasa como VARCHAR(es decir SqlDbType.VarChar). Si tiene caracteres ASCII no estándar (es decir, valores 128 y superiores) y los está pasando comoVARCHAR , es probable que vea "?" para caracteres BMP y "??" para caracteres suplementarios, ya que SQL Server convertirá la cadena UTF-16 de .NET en una cadena de 8 bits de la página de códigos de la base de datos actual antes de volver a convertirla en UTF-16 / UCS-2. Pero no debería recibir ningún error.

Por otro lado, si especifica la declaración XML, debe pasar a SQL Server utilizando el tipo de datos de 8 o 16 bits correspondiente. Entonces, si tiene una declaración que indica que la codificación es UCS-2 o UTF-16, debe pasar como SqlDbType.NVarCharo SqlDbType.Xml. O, si usted tiene una declaración de que la codificación es una de las opciones de 8 bits (es decir UTF-8, Windows-1252, iso-8859-1, etc), entonces usted debe pasar en tan SqlDbType.VarChar. Si no coincide la codificación declarada con el tipo de datos de SQL Server de 8 o 16 bits adecuado, se producirá el error "No se puede cambiar la codificación" que estaba recibiendo.

Por ejemplo, usando su StringWritercódigo de serialización basado en, simplemente imprimí la cadena resultante del XML y la usé en SSMS. Como puede ver a continuación, se incluye la declaración XML (porque StringWriterno tiene una opción para Me OmitXmlDeclarationgusta XmlWriter), lo que no plantea ningún problema siempre que pase la cadena como el tipo de datos SQL Server correcto:

-- 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>

Como puede ver, incluso maneja caracteres más allá de ASCII estándar, dado que ሴes el punto de código BMP U + 1234, y 😸es el punto de código de carácter suplementario U + 1F638. Sin embargo, lo siguiente:

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

da como resultado el siguiente error:

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

Ergo, dejando de lado toda esa explicación, la solución completa a su pregunta original es:

Claramente estabas pasando la cuerda como SqlDbType.VarChar. Cambie a SqlDbType.NVarChary funcionará sin necesidad de pasar por el paso adicional de eliminar la declaración XML. Se prefiere a mantener SqlDbType.VarChary eliminar la declaración XML porque esta solución evitará la pérdida de datos cuando el XML incluye caracteres ASCII no estándar. Por ejemplo:

-- 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>

Como puede ver, esta vez no hay ningún error, pero ahora hay pérdida de datos 🙀.

Un problema StringWriteres que, de forma predeterminada , no le permite configurar la codificación que anuncia , por lo que puede terminar con un documento XML que anuncia su codificación como UTF-16, lo que significa que debe codificarlo como UTF-16 si escríbalo en un archivo. Sin embargo, tengo una clase pequeña para ayudar con eso:

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

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

O si solo necesita UTF-8 (que es todo lo que a menudo necesito):

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

En cuanto a por qué no pudo guardar su XML en la base de datos, tendrá que darnos más detalles sobre lo que sucedió cuando lo intentó, si desea que podamos diagnosticarlo / solucionarlo.

Al serializar un documento XML en una cadena .NET, la codificación debe establecerse en UTF-16. Las cadenas se almacenan como UTF-16 internamente, por lo que esta es la única codificación que tiene sentido. Si desea almacenar datos en una codificación diferente, use una matriz de bytes en su lugar.

SQL Server funciona con un principio similar; cualquier cadena que se pase a una xmlcolumna debe codificarse como UTF-16. SQL Server rechazará cualquier cadena en la que la declaración XML no especifique UTF-16. Si la declaración XML no está presente, entonces el estándar XML requiere que esté predeterminado en UTF-8, por lo que SQL Server también lo rechazará.

Teniendo esto en cuenta, aquí hay algunos métodos de utilidad para realizar la conversión.

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);
        }
    }
}

En primer lugar, tenga cuidado de no encontrar ejemplos antiguos. Ha encontrado uno que usa XmlTextWriter, que está obsoleto a partir de .NET 2.0. XmlWriter.Createdebería utilizarse en su lugar.

Aquí hay un ejemplo de serialización de un objeto en una columna 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;
}

Es posible que se haya cubierto en otro lugar, pero simplemente cambiar la línea de codificación de la fuente XML a 'utf-16' permite que el XML se inserte en un tipo de datos 'xml' de 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();
    }
}

El resultado es que todo el texto XML se inserta en el campo de tipo de datos 'xml', pero se elimina la línea de 'encabezado'. Lo que ves en el registro resultante es solo

<test></test>

El uso del método de serialización descrito en la entrada "Respondido" es una forma de incluir el encabezado original en el campo de destino, pero el resultado es que el texto XML restante se incluye en una <string></string>etiqueta XML .

El adaptador de tabla en el código es una clase creada automáticamente con el asistente "Agregar nueva fuente de datos: de Visual Studio 2013". Los cinco parámetros del método Insertar se asignan a los campos de una tabla de SQL Server.