Ignore a property during xml serialization but not during deserialization

In C#, how can I make XmlSerializer ignore a property during serialization but not during deserialization? (Or how do I do the same with Json.net?)

To prevent a property from being serialized, you can add the XmlIgnore attribute:

[XmlIgnore]
public int FooBar {get;set;}

This will cause the <FooBar> tag to be omitted during serialization.

However, this also means that the <FooBar> tag will be ignored during deserialization.

In my case, I accept an array of items from user in the request, and for each item user can specify an action property if they want to add, modify or delete the item. I want to use the same model object for GET list calls, and don't want to return this action property. I expect this would be a pretty common case.

Another use case: say you have a circle object

public class Circle
{
    public double Radius { get; set; }
}

and you modify it to add a diameter property

public class Circle2
{
    public double Diameter { get; set; }
    public double Radius { get { return Diameter / 2; } set { Diameter = value*2; } }
}

You may want to serialize only the diameter, but still be able to deserialize xml files in the old format that contain only the radius.

I did my research and didn't find anything, hence this question

Solution: I figured out the solution. I can add a ShouldSerialize property which always return false, details at this MSDN documentation

(this solution could be added as an actual answer if this question is reopened)

Solution 1:

This is the solution outlined by Manoj:

If you want to suppress serialization of a specific property Foo, but still be able to deserialize it, you can add a method public bool ShouldSerializeFoo() that always returns false.

Example:

public class Circle2
{
    public double Diameter { get; set; }
    public double Radius { get { return Diameter / 2; } set { Diameter = value*2; } }

    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
    public bool ShouldSerializeRadius() {return false;}
}

This will cause the Radius to not be serialized, but still allow it to be deserialized.

This method has to be public for the XMLSerializer to find it, so in order to avoid polluting the namespace you can add the EditorBrowsable attribute to hide it from the IDE. Unfortunately this hiding only works if the assembly is referenced as a DLL in your current project, but not if you edit the actual project with this code.

Solution 2:

If you want to ignore the element at serialization with XmlSerializer, you can use XmlAttributeOverrides:

XmlAttributeOverrides overrides = new XmlAttributeOverrides();
XmlAttributes attribs = new XmlAttributes();
attribs.XmlIgnore = true;
attribs.XmlElements.Add(new XmlElementAttribute("YourElementName"));
overrides.Add(typeof(YourClass), "YourElementName", attribs);

XmlSerializer ser = new XmlSerializer(typeof(YourClass), overrides);
ser.Serialize(...