Develop Reference

Serialize DateTime property to XML in C#

I´m a programming student and I would like to know if it is possible to change the format of a date when I serialize it in a xml file. This date is an attribute of an ObservableCollection of objects "Loan", this objects have two DateTime properties, one of the dates is a nullable object. I serialize all the collection including the date.
I would like to obtain in the xml file:
<OutDate> 15-03-2014 </OutDate>
<!--If the date is null I don´t want to appear the node-->
And I´m getting this:
<OutDate>2014-03-15T00:00:00</OutDate>
<InDate xsi:nil="true" />
This is part of my code project:
Part of my class Loan, already mark as serializable, looks like this:
private string isbn;
private string dni;
private DateTime dateOut;
private DateTime? dateIn;
// Setters and Gettters and constructors
This is the method for serialize:
// I will pass three collections to this method loans, books and clients
public void SerializeToXML<T>(string file, string node, ObservableCollection<T> collection)
{
XmlRootAttribute root = new XmlRootAttribute(node);
XmlSerializer serializer = new XmlSerializer(typeof(ObservableCollection<T>), root);
using (FileStream fs = new FileStream(file, FileMode.Create))
{
serializer.Serialize(fs, collection);
}
}
The call:
SerializeToXML<Loan>(_file, "Library", manager.LoansCollection);
Thnks.

If you don't want to implement IXmlSerializable, some DateTime to string conversion of a backing field should do the trick, something like this:
public class Loan
{
[XmlIgnore]
private DateTime _dateOut;
public string OutDate
{
get { return _dateOut.ToString("dd-MM-yyyy"); }
set { _dateOut = DateTime.Parse(value); }
}
}

Probably the simplest way to achieve this is to implement the IXmlSerializable interface on your class instead. Something along the following lines
public class Loan : IXmlSerializable
{
public void WriteXml(XmlWriter writer)
{
if(dateIn.HasValue)
{
writer.WriteElementString("dateIn", dateIn.Value.ToString());
}
}
}
On the read you'll need to read the Element name, if it's dateIn set that, otherwise set the appropriate value. Basically checking to see if it exists in the XML.

Have a look at the XmlElement attribute class (in System.Xml.Serialization). If that doesn't work then this answer shows how to use a proxy property
[XmlElement("TheDate", DataType = "date")]
public DateTime TheDate { get; set; }

I know it's late to get my answer marked as "the one", but you can have control over serialization without implementing complex interfaces or wrapping stuff as a workaround.
public DateTime? InDate { get; set }
public bool ShouldSerializeInDate()
{
return InDate.HasValue;
}
The C# XML Serializer has a not so well documented functionality. Every public property can have a method for turning on or off the serialization of the property. The method has to be called: ShouldSerializeXYZ where XYZ is the exact name of the property that you want to control.
See:
Xml serialization - Hide null values

Deserialization an xml element that could be different types

I need to deserialize the flowing xml in c#
<Show>
<status>Canceled</status>
</Show>
<Show>
<status>2</status>
</Show>
my class is
[XmlRoot("Show")]`
public class Show
{
[XmlElement(ElementName = "status")]
public object status { get; set; }
}
and it works but i would like to deserialize it into an enum where in this example cancel is equal 2
public enum ShowStatus
{
[XmlEnum("Canceled")]
Canceled = 2
}
is there any way to do that without parse the public object status { get; set; } string value to enum

If you want to Deserialize the Enum using the name or the integer you can decorate the Enum with XmlEnum attribute and supply the integer.
This will deserialise "Canceled" and "2" as your Enum.
Example:
[XmlRoot("Show")]
public class Show
{
[XmlElement(ElementName = "status")]
public ShowStatus status { get; set; }
}
public enum ShowStatus
{
[XmlEnum("2")]
Canceled = 2
}
Test xml:
<?xml version="1.0"?>
<ArrayOfShow xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<Show>
<status>Canceled</status>
</Show>
<Show>
<status>2</status>
</Show>
</ArrayOfShow>

you cannot use object directly, XmlSerializer simply refuses to work with generics. Objects still have an underlying type, and when its de-serialzied, you have no idea what that type is. I made a workaround for it here but its not very pretty, or very useful.
You can custom implement IXmlSerializable, but that is a headache and a half.
I am assuming that the source of the problem is that you are taking this in as input from another source, and the field could be either integer or text, which you want to store as an enumerable. You are probably better of de-serializing it into a string, then simply parsing it later, afterwards. That would probably be the easiest way to do it. Everything else I can find is either about deserializing only the string values, or only the integer values, I have no idea if either of them can handle both forms of data, but it seems unlikely.
This Function will probably help you out a lot when it comes to that, it looks like it can handle the string or the numerical value, but I dont think XmlSerializer can use it. You would be better off with a string "dummy" that can save back to the Enum property using the Parse function. see this stackoverflow question for an example of the dummy property.
Example
Generally speaking it would look something like this:
[XmlRoot("Show")]`
public class Show
{
[XmlIgnore()]
public ShowStatus status { get; set; }
[XmlElement(ElementName = "status")]
public string StatusString
{
get { return status.ToString(); }
set { status = Enum.Parse(ShowStatus, value); }
}
}

C# Xml Deserialize plus design suggestions

In my project I need to build a generic deserializer that should be backward compatible.
Example: The XML looks like
<PolicyDef name = "sample" type="type1">
<Options ......>
</PolicyDef>
The "type" is enum - PolicyTypes
e.g
public Enum PolicyTypes
{
type1 = 0,
type2 = 1
}
The PolicyDef class is defined as
[XmlRoot("PolicyDef")]
public class PolicyDef
{
private string policyName;
private PolicyTypes policyType;
public PolicyDefinition()
{
}
[XmlAttribute]
public string Name
{
get
{
return this.policyName;
}
set
{
this.policyName = value;
}
}
[XmlAttribute]
public PolicyTypes Type
{
get
{
return this.policyType;
}
set
{
this.policyType = value;
}
}
}
The Problem with this approach is that if later on I put any type other than type 1 or type 2, the XMLDeserializer will throw exception.
so if i have the xml like
<PolicyDef name = "sample" type="type_new">
<Options ......>
</PolicyDef>
The deserializer will throw error as type_new not valid.
I was wondering if there is a way to hook into the deserializer process to catch that and set a default value rather than throw error. Say if there is any invalid value, then I would set that to "type1"
Or am open to suggestions regarding how to handle this problem
Thanks and Regards

This is possibly a duplicate of C# XML Deserialization W/ Default Values
Unfortunately it seems there is no way to fall back on default enum values during deserialisation. It will require slightly more work, but if you follow the linked example and implement IXmlSerializable in your PolicyDef class, you'll be able to implement the ReadXml method in a similar way (reflecting each of the properties using a try/catch block in order to check for a default value).
Hope that helps!

Thanks Chris for the suggestion, but I don't want end up writing the complete parsing code which could be messy if the XML and corresponding class is huge and complex. I anyway used a different approach.
I changed all the enum fields to string. In this case there would be no parsing error and then expose another property that would return the parsed value as enum and if the parsing fails, then return default enum value. E.g
private string policyName;
[XmlAttribute("Type")]
public string Type
{
private get
{
return this.policyType;
}
set
{
this.policyType = value;
try
{
this.PolicyType = (PolicyTypes)Enum.Parse(typeof(PolicyTypes), this.policyType);
}
catch(Exception)
{
this.PolicyType = PolicyTypes.DefaultPolicy;
}
}
}
public PolicyTypes PolicyType
{
get;
private set;
}
And use the class property to access the value rather than the xml attribute field.

IXmlSerializable

Could you guys help me I have a problem with deserialization via IXmlSerializable
var ArrayOfAccounts = new Accounts(); //This class structure I'm trying to read
Class Accounts:List<Session>{ }
Class Shedule{
public DateTime StartAt { get; set; }
public DateTime EndAt { get; set; }
}
Class Session:IXmlSerializable {
public string Name{get;set;}
public string Pass{get;set;}
public List<Shedule> Shedules = new List<Shedule>();
public void ReadXml(System.Xml.XmlReader reader){
//AND HERE IS A PROBLEM. I don't know how to implement right code here. I've tried
//code below, but this one works for the first account only, and doesn't restore others
Schedules.Clear();
XmlReader subR = reader.ReadSubtree();
if (reader.MoveToAttribute("Name"))
Name = reader.Value;
if (reader.MoveToAttribute("Password"))
Password = reader.Value;
reader.MoveToContent();
while (subR.ReadToFollowing("Schedule"))
{
XmlSerializer x = new XmlSerializer(typeof(Schedule));
object o = x.Deserialize(subR);
if (o is Schedule) Schedules.Add((Schedule)o);
}
}
And the xml itself looks like:
<Accounts>
<Session UserName="18SRO" Password="shalom99">
<Schedule>
<StartAt>0001-01-01T09:30:00</StartAt>
<EndAt>0001-01-01T16:00:00</EndAt>
</Schedule>
</Session>
</Accounts>

Since you've defined the classes, you should just be able to use XML Serialization attributes, and use the default XML deserializer.
Your structure doesn't look overly complicated, is there any particular reason you're not using serialization attributes instead of manually deserializing?

Re inherited fields... if you switch to DataContractSerializer, then fields are "opt in" rather than "opt out" - but you lose the ability to specify attributes (everything is an element). A trivial example:
[DataContract(Name="foo")]
public class Foo
{
[DataMember(Name="bar")]
public string Bar { get; set; }
public int ThisIsntSerialized {get;set;}
}
However - adding unexpected subclasses is a pain for both XmlSerializer and DataContractSerializer. Both can do it, but it isn't pretty...

Serializing an arraylist in C#

I have a class that contains a number of standard fields and an arraylist.
Is there any way to serialize the class using an XmlSerializer?
Attempts so far result in an error message saying:
Unhandled Exception: System.InvalidOperationException: There was an error
generating the XML document. ---> System.InvalidOperationException: The type
XMLSerialization.DataPoints was not expected. Use the XmlInclude or
SoapInclude attribute to specify types that are not known statically.
Some cut-down representations of the classes are shown below:
public class StationData
{
private DateTime _CollectionDate;
private string _StationID;
private ArrayList _PolledData;
public StationData()
{
}
public DateTime CollectionDate
{
get { return _CollectionDate; }
set { _CollectionDate = value; }
}
public string StationID
{
get { return _StationID; }
set { _StationID = value; }
}
[XmlInclude(typeof(DataPoints))]
public ArrayList PolledData
{
get { return _PolledData; }
set { _PolledData = value; }
}
}
public class DataPoints
{
private string _SubStationID;
private int _PointValue;
public DataPoints
{
}
public string SubStationID
{
get { return _SubStationID; }
set { _SubStationID = value; }
}
public int PointValue
{
get { return _PointValue; }
set { _PointValue = value; }
}
}

I have had success with the following:
[XmlArray("HasTypeSpecialisations")]
[XmlArrayItem("TypeObject", typeof(TypeObject), IsNullable = false)]
public List<TypeObject> TypeSpecialisations
This results in:
<HasTypeSpecialisations>
<TypeObject />
<TypeObject />
</HasTypeSpecialisations>
In your situation I would try something like:
[XmlArrayItem(typeof(DataPoints))]
public ArrayList PolledData
Based on this link http://msdn.microsoft.com/en-us/library/2baksw0z(VS.85).aspx you should also be able to use this
[XmlElement(Type = typeof(DataPoints))]
public ArrayList PolledData

The XmlSerializer generates some code at runtime to serialize your class. It is necessary for this class to know all types that can occur.
The ArrayList does not give this information, but you can give it by using a XmlInclude attribute on the property that returns the ArrayList.
[XmlInclude(typeof(DataPoints))]
public ArrayList Points {
...
}
You could also use the generic List<> class.

I think you could get around this by using a generic list (List<>) instead of an ArrayList, however, I'm going to assume you can't use generics for one reason or another.
You need to tell the compiler what type is contained in the ArrayList so it can serialize it since all it knows it that it contains objects.
Add this above your property and it should clear it up.
[System.Xml.Serialization.XmlInclude(typeof(XMLSerialization.DataPoints))]
Of course, replace XMLSerialization.DataPoints with whatever class is contained in the ArrayList.

Take a look at this article which describes the basic problem you are having and a solution around it (Like using the XmlInclude attribute). Basically what that says is that the serializer encountered a type it doesn't know how to serialize. If you post some code it would also help greatly.

The method I always used to serialize lists was to convert them to Arrays (which has the necessary type information). I admit this is a bit dirty, but if you can't get a proper list to serialize, this will work.