Cómo excluir propiedades nulos cuando se usa XmlSerializer

Question

estoy serializar una clase como esta

public MyClass 
{ 
    public int? a { get; set; } 
    public int? b { get; set; } 
    public int? c { get; set; } 
} 

Todos los tipos son anulable porque quiero un mínimo de datos almacenados al serializar un objeto de este tipo. Sin embargo, cuando se serializa sólo con "a" poblada, me sale el siguiente XML

<MyClass ...> 
    <a>3</a> 
    <b xsi:nil="true" /> 
    <c xsi:nil="true" /> 
</MyClass> 

¿Cómo fijo esto para conseguir solamente XML para las propiedades no nulos? La salida deseada sería

<MyClass ...> 
    <a>3</a> 
</MyClass> 

quiero excluir estos valores nulos, ya que habrá varias propiedades y esto se está poniendo almacena en una base de datos (sí, eso no es mi llamada) así que desee mantener los datos no utilizados mínimo .

Answer 1

Supongo que puede crear un XmlWriter que filtra todos los elementos con un atributo xsi: nil, y pasa todas las demás llamadas al escritor verdadero subyacente.

Answer 2

te ignoran elementos específicos con specification

public MyClass 
{ 
    public int? a { get; set; } 

    [System.Xml.Serialization.XmlIgnore] 
    public bool aSpecified { get { return this.a != null; } } 

    public int? b { get; set; } 
    [System.Xml.Serialization.XmlIgnore] 
    public bool bSpecified { get { return this.b != null; } } 

    public int? c { get; set; } 
    [System.Xml.Serialization.XmlIgnore] 
    public bool cSpecified { get { return this.c != null; } } 
} 

El campo {} Las propiedades especificadas le dirá al serializador si se debe serializar los campos correspondientes o no mediante la devolución de verdadero/falso.

Answer 3

La forma más sencilla de escribir código como este donde la salida exacta es importante es:

1. Escribir un esquema XML que describe el formato deseado exacta.
2. Convierta su esquema a una clase usando xsd.exe.
3. Convierta su clase nuevamente en un esquema (utilizando xsd.exe nuevamente) y compruébelo con su esquema original para asegurarse de que el serializador reproduzca correctamente cada comportamiento que desee.

Modifique y repita hasta que tenga el código de trabajo.

Si no está seguro de los tipos de datos exactos que debe usar inicialmente, comience con el paso 3 en lugar del paso 1, luego realice ajustes.

IIRC, para su ejemplo, casi seguramente terminará con las propiedades Specified como ya ha descrito, pero tenerlas generadas para usted es mejor que escribirlas a mano. :-)

Answer 4

¿Has leído SO: Serialize a nullable int?

Answer 5

Marque el elemento con [XmlElement ("elementName", IsNullable = false)] se omitirán los valores nulos.

Answer 6

vale tarde que nunca ...

he encontrado una manera (tal vez sólo está disponible con el último marco no sé) para hacer esto. que estaba usando DataMember atributo para un contrato de servicio web WCF y me marcó mi objeto como éste:

[DataMember(EmitDefaultValue = false)] 
public decimal? RentPrice { get; set; } 

Answer 7

otra solución: expresión regular para el rescate, utilice \s+<\w+ xsi:nil="true" \/> para eliminar todas las propiedades nulos de una cadena que contiene XML. Acepto, no es la solución más elegante, y solo funciona si solo tiene que serializar. Pero eso era todo lo que necesitaba hoy, y no quería agregar {Foo}Specified propiedades para todas las propiedades que pueden contener nulos.

public string ToXml() 
{ 
    string result; 

    var serializer = new XmlSerializer(this.GetType()); 

    using (var writer = new StringWriter()) 
    { 
     serializer.Serialize(writer, this); 
     result = writer.ToString(); 
    } 

    serializer = null; 

    // Replace all nullable fields, other solution would be to use add PropSpecified property for all properties that are not strings 
    result = Regex.Replace(result, "\\s+<\\w+ xsi:nil=\"true\" \\/>", string.Empty); 

    return result; 
} 

Answer 8

1) Extension

public static string Serialize<T>(this T value) { 
     if (value == null) { 
      return string.Empty; 
     } 
     try { 
      var xmlserializer = new XmlSerializer(typeof(T)); 
      var stringWriter = new Utf8StringWriter(); 
      using (var writer = XmlWriter.Create(stringWriter)) { 
       xmlserializer.Serialize(writer, value); 
       return stringWriter.ToString(); 
      } 
     } catch (Exception ex) { 
      throw new Exception("An error occurred", ex); 
     } 
    } 

1a) Utf8StringWriter

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

2) Crear XElement

XElement xml = XElement.Parse(objectToSerialization.Serialize()); 

3) Eliminar de Nil

xml.Descendants().Where(x => x.Value.IsNullOrEmpty() && x.Attributes().Where(y => y.Name.LocalName == "nil" && y.Value == "true").Count() > 0).Remove(); 

4) Guardar en archivo

xml.Save(xmlFilePath); 

Answer 9

Esta pregunta se ha pedido hace mucho tiempo, pero todavía es muy relevante incluso en 2017. Ninguna de las respuestas que aquí se propone no fuera satisfactorio para mí así que aquí tiene una solución simple que se me ocurrió:

El uso de expresiones regulares es la clave. Como no tenemos mucho control sobre el comportamiento del XmlSerializer, NO tratemos de impedir que serialice esos tipos de valor que aceptan valores. En su lugar, solo tome la salida serializada y reemplace los elementos no deseados con una cadena vacía usando Regex. El patrón utilizado (en C#) es:

<\w+\s+\w+:nil="true"(\s+xmlns:\w+="http://www.w3.org/2001/XMLSchema-instance")?\s*/> 

He aquí un ejemplo:

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

namespace MyNamespace 
{ 
    /// <summary> 
    /// Provides extension methods for XML-related operations. 
    /// </summary> 
    public static class XmlSerializerExtension 
    { 
     /// <summary> 
     /// Serializes the specified object and returns the XML document as a string. 
     /// </summary> 
     /// <param name="obj">The object to serialize.</param> 
     /// <param name="namespaces">The <see cref="XmlSerializerNamespaces"/> referenced by the object.</param> 
     /// <returns>An XML string that represents the serialized object.</returns> 
     public static string Serialize(this object obj, XmlSerializerNamespaces namespaces = null) 
     { 
      var xser = new XmlSerializer(obj.GetType()); 
      var sb = new StringBuilder(); 

      using (var sw = new StringWriter(sb)) 
      { 
       using (var xtw = new XmlTextWriter(sw)) 
       { 
        if (namespaces == null) 
         xser.Serialize(xtw, obj); 
        else 
         xser.Serialize(xtw, obj, namespaces); 
       } 
      } 

      return sb.ToString().StripNullableEmptyXmlElements(); 
     } 

     /// <summary> 
     /// Removes all empty XML elements that are marked with the nil="true" attribute. 
     /// </summary> 
     /// <param name="input">The input for which to replace the content. </param> 
     /// <param name="compactOutput">true to make the output more compact, if indentation was used; otherwise, false.</param> 
     /// <returns>A cleansed string.</returns> 
     public static string StripNullableEmptyXmlElements(this string input, bool compactOutput = false) 
     { 
      const RegexOptions OPTIONS = 
      RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace | RegexOptions.Multiline; 

      var result = Regex.Replace(
       input, 
       @"<\w+\s+\w+:nil=""true""(\s+xmlns:\w+=""http://www.w3.org/2001/XMLSchema-instance"")?\s*/>", 
       string.Empty, 
       OPTIONS 
      ); 

      if (compactOutput) 
      { 
       var sb = new StringBuilder(); 

       using (var sr = new StringReader(result)) 
       { 
        string ln; 

        while ((ln = sr.ReadLine()) != null) 
        { 
         if (!string.IsNullOrWhiteSpace(ln)) 
         { 
          sb.AppendLine(ln); 
         } 
        } 
       } 

       result = sb.ToString(); 
      } 

      return result; 
     } 
    } 
} 

espero que esto ayude.