Introduction

When XmlSerializer serializes a .NET object, null properties can show up in the XML either as missing elements or as explicit xsi:nil entries depending on how the model is annotated. If you want cleaner XML that omits null values entirely, you need to guide the serializer instead of relying on the default output format.

Use IsNullable = false to Omit Null Elements

For many reference-type properties, the simplest approach is to tell XmlSerializer not to emit a nullable XML element when the property is null.

1using System;
2using System.IO;
3using System.Xml.Serialization;
4
5public class Person
6{
7    public string FirstName { get; set; }
8
9    [XmlElement(IsNullable = false)]
10    public string MiddleName { get; set; }
11}
12
13var person = new Person
14{
15    FirstName = "Ada",
16    MiddleName = null
17};
18
19var serializer = new XmlSerializer(typeof(Person));
20serializer.Serialize(Console.Out, person);

With IsNullable = false, a null MiddleName is omitted instead of becoming an explicit nil element.

Use the ShouldSerialize Pattern for More Control

If you want custom logic instead of only null checks, XmlSerializer supports a ShouldSerializePropertyName convention. When that method returns false, the property is skipped.

1using System;
2using System.Xml.Serialization;
3
4public class Address
5{
6    public string Street { get; set; }
7    public string Apartment { get; set; }
8
9    public bool ShouldSerializeApartment()
10    {
11        return !string.IsNullOrWhiteSpace(Apartment);
12    }
13}

This is useful when a property should be omitted not only when it is null, but also when it is empty, whitespace-only, or otherwise semantically absent.

Know the Difference Between Omitted and Explicitly Nil

Sometimes the consuming system cares about the distinction between:

• An element not being present at all
• An element being present with a nil marker

Those are not the same thing in XML contracts. If the receiving system expects xsi:nil="true", hiding the node entirely may break compatibility. That is why the correct choice depends on the schema and integration contract, not only on aesthetics.

A quick serialization helper makes the result easy to inspect:

1using System.IO;
2using System.Xml.Serialization;
3
4public static string ToXml<T>(T value)
5{
6    var serializer = new XmlSerializer(typeof(T));
7    using var writer = new StringWriter();
8    serializer.Serialize(writer, value);
9    return writer.ToString();
10}

Once you can inspect the exact output, it becomes much easier to validate whether nulls are omitted the way you intended.

Another Option: Specified Members

For some XML serialization scenarios, especially schema-driven ones, a paired PropertyNameSpecified boolean can control whether a value is serialized.

1public class Order
2{
3    public decimal Total { get; set; }
4
5    [XmlIgnore]
6    public bool TotalSpecified { get; set; }
7}

When TotalSpecified is false, Total is skipped during serialization. This pattern is more verbose, but it is useful for optional value types that cannot be null by themselves.

Common Pitfalls

The biggest mistake is assuming every serializer in .NET behaves the same way. XmlSerializer, DataContractSerializer, and JSON serializers have different conventions, so advice for one does not automatically apply to another.

Another issue is hiding null values without checking the receiving schema. Some integrations depend on an explicit nil element, and removing it can change the meaning of the message.

Developers also sometimes expect IsNullable = false to solve every conditional serialization need. It only addresses null emission. If the property needs richer rules, ShouldSerialize... or a Specified companion member is usually the better tool.

Finally, always inspect the generated XML rather than assuming your attributes had the intended effect. Serialization behavior is easy to misunderstand when you only look at the model class and not at the actual output.

Summary

• 'XmlSerializer can omit null values, but you must configure the model intentionally.'
• 'XmlElement(IsNullable = false) is the simplest way to skip null reference-type elements.'
• 'ShouldSerializePropertyName gives more flexible conditional serialization.'
• 'PropertyNameSpecified is useful for optional value-type members.'
• Always validate the XML contract before hiding nulls, because omitted and nil are not equivalent.