XML-Serialisierung - Nullwerte ausblenden

Kann ich bei Verwendung eines standardmäßigen .NET Xml-Serializers alle Nullwerte ausblenden? Das Folgende ist ein Beispiel für die Ausgabe meiner Klasse. Ich möchte die nullbaren Ganzzahlen nicht ausgeben, wenn sie auf null gesetzt sind.

Aktuelle XML-Ausgabe:

<?xml version="1.0" encoding="utf-8"?>
<myClass>
   <myNullableInt p2:nil="true" xmlns:p2="http://www.w3.org/2001/XMLSchema-instance" />
   <myOtherInt>-1</myOtherInt>
</myClass>

Was ich möchte:

<?xml version="1.0" encoding="utf-8"?>
<myClass>
   <myOtherInt>-1</myOtherInt>
</myClass>

Sie können eine Funktion mit dem Muster erstellen, ShouldSerialize{PropertyName}die dem XmlSerializer mitteilt, ob das Mitglied serialisiert werden soll oder nicht.

Wenn Ihre Klasseneigenschaft beispielsweise aufgerufen wird MyNullableInt, könnten Sie haben

public bool ShouldSerializeMyNullableInt() 
{
  return MyNullableInt.HasValue;
}

Hier ist ein vollständiges Beispiel

public class Person
{
  public string Name {get;set;}
  public int? Age {get;set;}
  public bool ShouldSerializeAge()
  {
    return Age.HasValue;
  }
}

Serialisiert mit dem folgenden Code

Person thePerson = new Person(){Name="Chris"};
XmlSerializer xs = new XmlSerializer(typeof(Person));
StringWriter sw = new StringWriter();
xs.Serialize(sw, thePerson);

Ergebnisse in der folgenden XML - Beachten Sie, dass es kein Alter gibt

<Person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Name>Chris</Name>
</Person>

Zusätzlich zu dem, was Chris Taylor geschrieben hat: Wenn Sie etwas als Attribut serialisiert haben, können Sie eine Eigenschaft in Ihrer Klasse benennen, um {PropertyName}Specifiedzu steuern, ob es serialisiert werden soll. In Code:

public class MyClass
{
    [XmlAttribute]
    public int MyValue;

    [XmlIgnore]
    public bool MyValueSpecified;
}

Es existiert eine Eigenschaft namens XmlElementAttribute.IsNullable

Wenn die IsNullable-Eigenschaft auf true festgelegt ist, wird das Attribut xsi: nil für Klassenmitglieder generiert, die auf eine Nullreferenz festgelegt wurden.

Das folgende Beispiel zeigt ein Feld, auf das XmlElementAttributedas Feld angewendet wurde, und die IsNullable-Eigenschaft ist auf false gesetzt.

public class MyClass
{
   [XmlElement(IsNullable = false)]
   public string Group;
}

Sie können nach anderen suchen, XmlElementAttributeum Namen in der Serialisierung usw. zu ändern.

Sie können einige Standardwerte definieren und verhindern, dass die Felder serialisiert werden.

    [XmlElement, DefaultValue("")]
    string data;

    [XmlArray, DefaultValue(null)]
    List<string> data;

Ich bevorzuge es, meine eigene XML ohne automatisch generierte Tags zu erstellen. In diesem Fall kann ich das Erstellen der Knoten mit Nullwerten ignorieren:

public static string ConvertToXML<T>(T objectToConvert)
    {
        XmlDocument doc = new XmlDocument();
        XmlNode root = doc.CreateNode(XmlNodeType.Element, objectToConvert.GetType().Name, string.Empty);
        doc.AppendChild(root);
        XmlNode childNode;

        PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(typeof(T));
        foreach (PropertyDescriptor prop in properties)
        {
            if (prop.GetValue(objectToConvert) != null)
            {
                childNode = doc.CreateNode(XmlNodeType.Element, prop.Name, string.Empty);
                childNode.InnerText = prop.GetValue(objectToConvert).ToString();
                root.AppendChild(childNode);
            }
        }            

        return doc.OuterXml;
    }

private static string ToXml(Person obj)
{
  XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces();
  namespaces.Add(string.Empty, string.Empty);

  string retval = null;
  if (obj != null)
  {
    StringBuilder sb = new StringBuilder();
    using (XmlWriter writer = XmlWriter.Create(sb, new XmlWriterSettings() { OmitXmlDeclaration = true }))
    {
      new XmlSerializer(obj.GetType()).Serialize(writer, obj,namespaces);
    }
    retval = sb.ToString();
  }
  return retval;
}

In meinem Fall waren die nullbaren Variablen / Elemente alle vom Typ String. Also habe ich einfach eine Prüfung durchgeführt und ihnen einen String zugewiesen. Leer bei NULL. Auf diese Weise habe ich die unnötigen Attribute nil und xmlns entfernt (p3: nil = "true" xmlns: p3 = "http://www.w3.org/2001/XMLSchema-instance)

// Example:

myNullableStringElement = varCarryingValue ?? string.Empty

// OR

myNullableStringElement = myNullableStringElement ?? string.Empty