Why Isn't My Public Property Serialized by the Xmlserializer

Why isn't my public property serialized by the XmlSerializer?

As mentioned, most properties must have both a getter and setter; the main exception to this is lists - for example:

private readonly List<Foo> bar = new List<Foo>();
public List<Foo> Bar {get { return bar; } } // works fine

which will work fine; however, if XmlSerializer finds a setter - it demands that it is public; the following will not work:

public List<Foo> Bar {get; private set;} // FAIL

Other reasons it might not serialize:

• it isn't public with get and set (or is readonly for a field)
• it has a [DefaultValue] attribute, and is with that value
• it has a public bool ShouldSerializeFoo() method that returned false
• it has a public bool FooSpecified {get;set;} property or field that returned false
• it is marked [XmlIgnore]
• it is marked [Obsolete]

Any of these will cause it not to serialize

Why can't I serialize readonly fields with XmlSerializer?

That's quite a good question, and I'll try my best to answer:

1. I believe the reason for the setter as well as the getter is that it's generally assumed if you've only got a getter, then it implies it's not an instance property, it's something that is derived. That would imply if you were to deserialize it (I know you're not doing this) then you could derive this value by setting all the other fields, and therefore serialization doesn't need to care about it.

2. The reason the parameterless constructor is required is because the type will be created using Reflection. Probably through a call like Activator.CreateInstace(type). This requires a parameterless constructor for the instance to be created, although it probably doesn't matter if it's public or private.

   The reason the instance is required is so the fields on it can then be populated with the data retrieved from the XML.

3. You'll need this constructor, however you could add the ObsoleteAttribute to ensure that it's not called manually, or do as you're doing and make it private.

   [Obsolete(true)]
   public Foo() 
   {
   
   }
   

One way of working around some of these issues may be to implement the IXmlSerializable interface manually, then you have a finer control over serialization but will still need that parameterless constructor.

How to tell XmlSerializer to serialize properties with [DefautValue(...)] always?

As long as you don't need attributes in your Xml, if you use the DataContractSerializer instead you will get the behavior you desire.

[DataContract]
public class Test
{
    [DataMember]
    [DefaultValue(false)]
    public bool AllowNegative { get; set; }
}

void Main()
{
    var sb2 = new StringBuilder();
    var dcs = new DataContractSerializer(typeof(Test));

    using(var writer = XmlWriter.Create(sb2))
    {
        dcs.WriteObject(writer, new Test());
    }

    Console.WriteLine(sb2.ToString());  
}

produces (minus namespaces etc)

<Test>
    <AllowNegative>false</AllowNegative>
</Test>

XML Serialization of public property backing private field in C#

Check this answer right here:

Why are properties without a setter not serialized

Seems like it is a serializer limitation (by design) when you have "readonly" properties, try adding a "setter" and it might work.

Why is my Type not being Serialized correctly by the XmlSerializer

This is kind of an old question, but oh well. I think the solution might be in another question "Why isn't my public property serialized by the XmlSerializer?". Part of the answer lists reasons why an attribute would not be serialized and in that list is

• it has a public bool FooSpecified {get;set;} property that returned false

In your code, you set the various Boolean values but set the related specified values. I was facing a similar issue and setting the specified value fixed it for me.

XmlSerializer with parameterless constructor with no public properties or fields... Is it possible?

XmlSerializer only cares about public read/write members. One option is to implement IXmlSerializable, but that is a lot of work. A more practical option (if available and suitable) may be to use DataContractSerializer:

[DataContract]
public class Something
{
    [DataMember]
    public string Text {get; private set;}

    private Something()
    {
        Text = string.Empty;
    }

    public Something(string text)
    {
        Text = text;
    }
}

This works on both public and private members, but the xml produced is not quite the same, and you can't specify xml attributes.

---

Related Topics