Serializacja XML - Ukryj wartości null

Czy podczas używania standardowego serializatora .NET Xml można ukryć wszystkie wartości null? Poniżej znajduje się przykład wyniku mojej klasy. Nie chcę wyprowadzać liczb całkowitych dopuszczających wartość null, jeśli są ustawione na null.

Bieżące wyjście XML:

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

Czego chcę:

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

Możesz utworzyć funkcję z wzorcem, ShouldSerialize{PropertyName}który informuje XmlSerializer, czy powinien serializować element członkowski, czy nie.

Na przykład, jeśli wywoływana jest właściwość klasy, MyNullableIntmożesz mieć

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

Oto pełna próbka

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

Serializowane za pomocą następującego kodu

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

Wyniki w następującym formacie XML - Zauważ, że nie ma wieku

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

Oprócz tego, co napisał Chris Taylor: jeśli masz coś serializowanego jako atrybut, możesz mieć właściwość w swojej klasie o nazwie, {PropertyName}Specifiedaby kontrolować, czy powinna być serializowana. W kodzie:

public class MyClass
{
    [XmlAttribute]
    public int MyValue;

    [XmlIgnore]
    public bool MyValueSpecified;
}

Istnieje własność zwana XmlElementAttribute.IsNullable

Jeśli właściwość IsNullable ma wartość true, atrybut xsi: nil jest generowany dla elementów członkowskich klasy, dla których ustawiono odwołanie o wartości null.

Poniższy przykład przedstawia pole z XmlElementAttributezastosowanym do niego, a właściwość IsNullable ustawiona na false.

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

Możesz spojrzeć na inne, XmlElementAttributeaby zmienić nazwy w serializacji itp.

Można zdefiniować pewne wartości domyślne i zapobiega to serializacji pól.

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

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

Wolę tworzyć własne pliki XML bez tagów generowanych automatycznie. W tym mogę zignorować tworzenie węzłów z wartościami null:

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

W moim przypadku wszystkie zmienne / elementy dopuszczające wartość null były typu String. Więc po prostu sprawdziłem i przypisałem im ciąg. Puste w przypadku NULL. W ten sposób pozbyłem się niepotrzebnych atrybutów nil i xmlns (p3: nil = "true" xmlns: p3 = "http://www.w3.org/2001/XMLSchema-instance)

// Example:

myNullableStringElement = varCarryingValue ?? string.Empty

// OR

myNullableStringElement = myNullableStringElement ?? string.Empty