Deserialize XML to ObservableCollection - wpf

Question

Using VS 2012 and .NET 4.0, I have the following code which correctly deserializes an XML file:
XML File:
<?xml version="1.0"?>
<Codes xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema" >
<Code>
<AccpacCode>CA9998</AccpacCode>
<LAC>90699999999999999</LAC>
<SCSCode>SDI</SCSCode>
</Code>
<Code>
<AccpacCode>ORWC</AccpacCode>
<LAC>94199999999999999</LAC>
<SCSCode>WC</SCSCode>
</Code>
<Code>
<AccpacCode>AK9999</AccpacCode>
<LAC>90299999999999999</LAC>
<SCSCode>UI</SCSCode>
<ParentEmployerAccpacCode>AKSUTA</ParentEmployerAccpacCode>
</Code>
<Codes>
XSD File:
<?xml version="1.0" encoding="utf-8"?>
<xs:schema id="Codes" xmlns="SerializeObservableCollection" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xs:element name="Codes" msdata:IsDataSet="true" msdata:UseCurrentLocale="true">
<xs:complexType>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="Code">
<xs:complexType>
<xs:sequence>
<xs:element name="AccpacCode" type="xs:string" minOccurs="0" />
<xs:element name="LAC" type="xs:string" minOccurs="0" />
<xs:element name="SCSCode" type="xs:string" minOccurs="0" />
<xs:element name="ParentEmployerAccpacCode" type="xs:string" minOccurs="0" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>
C# Code:
try
{
XmlSerializer _serializer = new XmlSerializer(typeof(Codes));
// A file stream is used to read the XML file into the ObservableCollection
using (StreamReader _reader = new StreamReader(#"LocalCodes.xml"))
{
var codes = _serializer.Deserialize(_reader) as Codes;
}
}
catch (Exception ex)
{
// Catch exceptions here
}
I would like to put the results of the deserialization into an ObservableCollection and have found examples that say the following should work:
ObservableCollection<Codes> CodeCollection;
...
try
{
XmlSerializer _serializer = new XmlSerializer(typeof(ObservableCollection<Codes>));
// A file stream is used to read the XML file into the ObservableCollection
using (StreamReader _reader = new StreamReader(#"LocalCodes.xml"))
{
CodeCollection = _serializer.Deserialize(_reader) as ObservableCollection<Codes>;
}
}
When I run this code I get an error message of "There is an error in XML document (2, 2)." and an inner exception of "<Codes xmlns=''> was not expected." I have seen mention of needing a default constructor to make this work and the Codes.cs class does have one (it is the file generated by VS 2012 by the XSD file). here is a snippet of the Codes.cs file:
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.18051
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
#pragma warning disable 1591
namespace SerializeObservableCollection {
/// <summary>
///Represents a strongly typed in-memory cache of data.
///</summary>
[global::System.Serializable()]
[global::System.ComponentModel.DesignerCategoryAttribute("code")]
[global::System.ComponentModel.ToolboxItem(true)]
[global::System.Xml.Serialization.XmlSchemaProviderAttribute("GetTypedDataSetSchema")]
[global::System.Xml.Serialization.XmlRootAttribute("Codes")]
[global::System.ComponentModel.Design.HelpKeywordAttribute("vs.data.DataSet")]
public partial class Codes : global::System.Data.DataSet {
private CodeDataTable tableCode;
private global::System.Data.SchemaSerializationMode _schemaSerializationMode = global::System.Data.SchemaSerializationMode.IncludeSchema;
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "4.0.0.0")]
public Codes() {
this.BeginInit();
this.InitClass();
global::System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new global::System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
base.Tables.CollectionChanged += schemaChangedHandler;
base.Relations.CollectionChanged += schemaChangedHandler;
this.EndInit();
}
What do I need to change/fix to get this to work and populate the ObservableCollection?

Answer 1

#BrianKE I doubt very much this will still be of use to you, but maybe it will be of use to someone else. I had the same problem as you today. Took me half the day to figure it out.
First, the message you are seeing is because the type you are specifying...
XmlSerializer _serializer = new XmlSerializer(typeof(ObservableCollection<Codes>));
..is not an ObservableCollection. If the type is wrong you get this error. Codes needs to be an observable collection for your statement to work.
What you need is root element, currently Codes is your root element, so you need a Class just for the root and then you have a number of Code elements under this. e.g.
[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.0.30319.33440")]
[System.SerializableAttribute()]
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType = true)]
[System.Xml.Serialization.XmlRootAttribute(Namespace = "", IsNullable = false)]
public partial class MIGRATION : object, INotifyPropertyChanged, INotifyPropertyChanging
{
private string projectNameField;
private ObservableCollection<FileDescriptions> fileDescriptionsField;
//private FileDescriptions[] fileDescriptionsField;
/// <remarks/>
//[System.Xml.Serialization.XmlElementAttribute(Form = System.Xml.Schema.XmlSchemaForm.Unqualified)]
[XmlElement("ProjectName")]
public string ProjectName
{
get
{
return this.projectNameField;
}
set
{
this.RaisePropertyChanging("ProjectName");
this.projectNameField = value;
this.RaisePropertyChanged("ProjectName");
}
}
/// <remarks/>
[XmlElement("FileDescriptions")]
public ObservableCollection<FileDescriptions> FileDescriptions
{
get
{
return this.fileDescriptionsField;
}
set
{
this.fileDescriptionsField = value;
this.RaisePropertyChanged("FileDescriptions");
}
}
public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
protected void RaisePropertyChanged(string propertyName)
{
System.ComponentModel.PropertyChangedEventHandler propertyChanged = this.PropertyChanged;
if ((propertyChanged != null))
{
propertyChanged(this, new System.ComponentModel.PropertyChangedEventArgs(propertyName));
}
}
public event System.ComponentModel.PropertyChangingEventHandler PropertyChanging;
protected void RaisePropertyChanging(string propertyName)
{
System.ComponentModel.PropertyChangingEventHandler propertyChanging = this.PropertyChanging;
if ((propertyChanging != null))
{
propertyChanging(this, new System.ComponentModel.PropertyChangingEventArgs(propertyName));
}
}
}
So the Observable collection(s) is on the elements inside the deserialized Class. I know what you are talking about though, I have seen examples like you are describing, but I don't know what that is about. As far as I can tell the deserialize had nothing to do with observable collection. Unless maybe they have more than one root element? Or perhaps it is when you are not deserializing a whole XML, but just a part of one, would make sense.

Answer 2

Deserialize should be used only with content that was previously serialized using Serialize. Otherwise, you are just playing with fire.
You can easily open and iterate through an XML document using XDocument.
XDocument xml = XDocument.Load(filename);
var collection = new ObservableCollection<Code>();
foreach (XElement e in xml.Elements("code"))
{
collection.Add(new Code() { AccpacCode = e.Element("AccpacCode").Value,
LAC = e.Element("LAC").Value });
}
You can easily iterate in all xml.Elements and intiatiate a code object which you add to an ObservableCollection. The interface may flickr a bit though during the loading.