XML Deserialize in Windows Phone C#

Question

i'm working on WP Application for news portal, I need to parse various feeds. Standard feed looks like this:

<feed>
    <items>
        <item>
            ...
        </item>
        <item>
            ...
        </item>
    </items>
</feed>

and I use this code to deserialize it:

XDocument document = XDocument.Load(xmlStream);
XmlSerializer serializer = new XmlSerializer(typeof(News));
News MainPage = (News)serializer.Deserialize(document.CreateReader());
Dispatcher.BeginInvoke(() => MainPageListBox.ItemsSource = MainPage.DataSet;);

the News class looks like this:

[XmlRoot("feed")]
public class News
{
    [XmlArray("items")]
    [XmlArrayItem("item")]
    public ObservableCollection<NewsItem> DataSet{ get; set; }
}

This work fine in every feed having this structure with one <items> section. But I also have feed with multiple sections, for example:

<feed>
    <items section="part 1">
        <item>
            ...
        </item>
        <item>
            ...
        </item>
    </items>
    <items section="part 2">
        <item>
            ...
        </item>
        <item>
            ...
        </item>
    </items>
</feed>

If I use C# code above, only first <items> section is parsed, others are ignored. I need to create separate List or ObservableCollection for each <items> section in single XML feed.

Can anyone help me with this? Thanks a lot.

Answer 1

Classes:

[XmlRoot("feed")]
    public class News
    {
        [XmlArray("items")]
        public List<NewsItemCollection> DataSet { get; set; }

        public News()
        {
            DataSet = new List<NewsItemCollection>();
        }
    }

    public class NewsItemCollection
    {
        [XmlAttribute("section")]
        public string Section { get; set; }

        [XmlElement("item")]
        public ObservableCollection<NewsItem> Items { get; set; }

        public NewsItemCollection()
        {
            Items = new ObservableCollection<NewsItem>();
        }
    }

    public class NewsItem
    {
        public string Title { get; set; }
    }

Some helper classes of mine for serializing/deserializing xml:

public static class ObjectExtensions
    {
        /// <summary>
        /// <para>Serializes the specified System.Object and writes the XML document</para>
        /// <para>to the specified file.</para>
        /// </summary>
        /// <typeparam name="T">This item's type</typeparam>
        /// <param name="item">This item</param>
        /// <param name="fileName">The file to which you want to write.</param>
        /// <returns>true if successful, otherwise false.</returns>
        public static bool XmlSerialize<T>(this T item, string fileName)
        {
            return item.XmlSerialize(fileName, true);
        }

        /// <summary>
        /// <para>Serializes the specified System.Object and writes the XML document</para>
        /// <para>to the specified file.</para>
        /// </summary>
        /// <typeparam name="T">This item's type</typeparam>
        /// <param name="item">This item</param>
        /// <param name="fileName">The file to which you want to write.</param>
        /// <param name="removeNamespaces">
        ///     <para>Specify whether to remove xml namespaces.</para>para>
        ///     <para>If your object has any XmlInclude attributes, then set this to false</para>
        /// </param>
        /// <returns>true if successful, otherwise false.</returns>
        public static bool XmlSerialize<T>(this T item, string fileName, bool removeNamespaces)
        {
            object locker = new object();

            XmlSerializerNamespaces xmlns = new XmlSerializerNamespaces();
            xmlns.Add(string.Empty, string.Empty);

            XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));

            XmlWriterSettings settings = new XmlWriterSettings();
            settings.Indent = true;
            settings.OmitXmlDeclaration = true;

            lock (locker)
            {
                using (XmlWriter writer = XmlWriter.Create(fileName, settings))
                {
                    if (removeNamespaces)
                    {
                        xmlSerializer.Serialize(writer, item, xmlns);
                    }
                    else { xmlSerializer.Serialize(writer, item); }

                    writer.Close();
                }
            }

            return true;
        }

        /// <summary>
        /// Serializes the specified System.Object and returns the serialized XML
        /// </summary>
        /// <typeparam name="T">This item's type</typeparam>
        /// <param name="item">This item</param>
        /// <returns>Serialized XML for specified System.Object</returns>
        public static string XmlSerialize<T>(this T item)
        {
            return item.XmlSerialize(true);
        }

        /// <summary>
        /// Serializes the specified System.Object and returns the serialized XML
        /// </summary>
        /// <typeparam name="T">This item's type</typeparam>
        /// <param name="item">This item</param>
        /// <param name="removeNamespaces">
        ///     <para>Specify whether to remove xml namespaces.</para>para>
        ///     <para>If your object has any XmlInclude attributes, then set this to false</para>
        /// </param>
        /// <returns>Serialized XML for specified System.Object</returns>
        public static string XmlSerialize<T>(this T item, bool removeNamespaces)
        {
            object locker = new object();

            XmlSerializerNamespaces xmlns = new XmlSerializerNamespaces();
            xmlns.Add(string.Empty, string.Empty);

            XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));

            XmlWriterSettings settings = new XmlWriterSettings();
            settings.Indent = true;
            settings.OmitXmlDeclaration = true;

            lock (locker)
            {
                StringBuilder stringBuilder = new StringBuilder();
                using (StringWriter stringWriter = new StringWriter(stringBuilder))
                {
                    using (XmlWriter xmlWriter = XmlWriter.Create(stringWriter, settings))
                    {
                        if (removeNamespaces)
                        {
                            xmlSerializer.Serialize(xmlWriter, item, xmlns);
                        }
                        else { xmlSerializer.Serialize(xmlWriter, item); }

                        return stringBuilder.ToString();
                    }
                }
            }
        }
    }

public static class StringExtensions
    {
        /// <summary>
        /// Deserializes the XML data contained by the specified System.String
        /// </summary>
        /// <typeparam name="T">The type of System.Object to be deserialized</typeparam>
        /// <param name="s">The System.String containing XML data</param>
        /// <returns>The System.Object being deserialized.</returns>
        public static T XmlDeserialize<T>(this string s)
        {
            var locker = new object();
            var stringReader = new StringReader(s);
            var reader = new XmlTextReader(stringReader);
            try
            {
                var xmlSerializer = new XmlSerializer(typeof(T));
                lock (locker)
                {
                    var item = (T)xmlSerializer.Deserialize(reader);
                    reader.Close();
                    return item;
                }
            }
            catch
            {
                return default(T);
            }
            finally
            {
                reader.Close();
            }
        }
    }

test run:

News news = new News();
            news.DataSet.Add(new NewsItemCollection
            {
                Section = "Section1",
                Items = new ObservableCollection<NewsItem>
                    {
                        new NewsItem { Title = "Test1.1" },
                        new NewsItem { Title = "Test1.2" }
                    }
            });
            news.DataSet.Add(new NewsItemCollection
            {
                Section = "Section2",
                Items = new ObservableCollection<NewsItem>
                    {
                        new NewsItem { Title = "Test2.1" },
                        new NewsItem { Title = "Test2.2" }
                    }
            });

            var serialized = news.XmlSerialize();
            var deserialized = serialized.XmlDeserialize<News>();

Have fun!