CODEWITHSUNDEEP
c#xmldeserialization
Brad R.
Brad R.

Reputation: 15

XmlArray with multiple names

I've searched for hours and found similar results but not for this specific scenario. Consider the following XML file.

<root>
<largeImages>
    <largeImage>
        <url>./imageLarge.jpg</url>
        <height>480</height>
        <width>640</width>
    </largeImage>
</largeImages>
<smallImages>
    <smallImage>
        <url>./imageSmall.jpg</url>
        <height>240</height>
        <width>320</width>
    </smallImage>
</smallImages>
</root>

What I'm trying to do is deserialize this into a single array of images instead of 2 arrays.

public class root {
    [XmlArray("largeImages")]
    [XmlArrayItem("largeImage")]
    public image[] largeImages { get; set; }

    [XmlArray("smallImages")]
    [XmlArrayItem("smallImage")]
    public image[] smallImages { get; set; }
}

This class gets me 2 arrays. root.largeImages and root.smallImages. Since my application doesn't care about large or small images I'd like to deserialize into the single array root.images. I've tried variations of XmlArray, XmlArrayItem, XmlElement and even XmlChoiceIdentifier without any success. I'm thinking something along the lines of the following which won't compile because apparently the XmlArrayAttribute can only be used once per property.

[XmlArray("largeImages")]
[XmlArray("smallImages")]
[XmlArrayItem("largeImage")]
[XmlArrayItem("smallImage")]
public image[] images { get; set; }

Obviously I could merge the 2 arrays in code after the XML is deserialized but it seems like this should be a simple thing to do.

Upvotes: 1

Views: 2212

Answers (4)

Max K.
Max K.

Reputation: 1

I had a challenge with model serialization, and thanks to MSDN I found the answer. Here is my solution:

public class Document
{
    [XmlElement(ElementName = "seller_id")]
    public string SellerId { get; set; }

    [XmlArray(ElementName = "order_details")]
    [XmlArrayItem(Type = typeof(SgtinCode), ElementName = "sgtin")]
    [XmlArrayItem(Type = typeof(SsccCode), ElementName = "sscc")]
    public Code[] Codes { get; set; }
}

public abstract class Code
{
    [XmlText]
    public string Value { get; set; }
}

public class SgtinCode : Code
{ }

public class SsccCode : Code
{ }

Model setup:

var document = new Document
{
    SellerId = Guid.NewGuid().ToString(),
    Codes = new Code[]
    {
        new SsccCode { Value = "111700126101510000000000011" },
        new SsccCode { Value ="111700126101510000000000012" },
        new SsccCode { Value ="111700126101510000000000013" },
        new SgtinCode { Value = "abc" }
    }
}

And XML output:

<?xml version="1.0" encoding="utf-8"?>
<documents>
  <foreign_shipment>
    <seller_id>fb2d35e7-c5d1-43ad-a272-89f897f41058</seller_id>
    <order_details>
      <sscc>111700126101510000000000011</sscc>
      <sscc>111700126101510000000000012</sscc>
      <sscc>111700126101510000000000013</sscc>
      <sgtin>abc</sgtin>
    </order_details>
  </foreign_shipment>
</documents>

Upvotes: 0

dbc
dbc

Reputation: 117283

Given that the answer from How to define multiple names for XmlElement field? works primarily for elements not arrays, the easiest solution would seem to be to introduce a surrogate property for one of the image elements, say <smallImages>:

public class root 
{
    [XmlArray("largeImages")]
    [XmlArrayItem("largeImage")]
    public List<image> Images { get; set; } = new List<image>();

    [XmlArray("smallImages")]
    [XmlArrayItem("smallImage")]
    [Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DebuggerBrowsable(DebuggerBrowsableState.Never)]
    public List<image> SmallImagesSurrogate { get { return Images; } }

    public bool ShouldSerializeSmallImagesSurrogate() { return false; }
}

Notes:

  • When deserializing to a pre-allocated List<T>, XmlSerializer will simply append deserialized elements to the existing list. That allows elements from both <largeImages> and <smallImages> to be concatenated into the same collection without data loss.

  • The surrogate property must be public but can be made "less visible" by setting attributes such as [Browsable(false)].

  • XmlSerializer can successfully deserialize get-only collection properties as long as the collection is pre-allocated. I took advantage of this to avoid adding a setter for the surrogate.

  • In case you need to re-serialize your root, the method ShouldSerializeSmallImagesSurrogate() will prevent the images array from being double-serialized. (For an explanation of why, see ShouldSerialize*() vs *Specified Conditional Serialization Pattern.) Instead all the images will serialize under <largeImages>. This method does not affect deserialization.

Sample working .Net fiddle.

Upvotes: 0

jdweng
jdweng

Reputation: 34433

Simple!!! I do it all the time. The trick is with root that you need to use Elements() and then use FirstOrDefault() to get only one.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Linq;

namespace ConsoleApplication1
{
    class Program
    {
        const string FILENAME = @"c:\temp\test.xml";
        static void Main(string[] args)
        {
            XDocument doc = XDocument.Load(FILENAME);

            Root root = doc.Elements("root").Select(x => new Root() {
                Images = x.Descendants("largeImage").Select(z => new Image() {
                    url = (string)z.Element("url"),
                    height = (int)z.Element("height"),
                    width = (int)z.Element("width")
                }).ToList()
            }).FirstOrDefault();

            root.Images.AddRange(doc.Descendants("smallImage").Select(z => new Image() {
                    url = (string)z.Element("url"),
                    height = (int)z.Element("height"),
                    width = (int)z.Element("width")
                }).ToList());
        }
    }
    public class Root
    {
        public List<Image> Images { get; set; }

    }
    public class Image
    {
        public string url { get; set; }
        public int height { get; set; }
        public int width { get; set; }
    }
}

Upvotes: 0

cyborg
cyborg

Reputation: 5748

XPATH is probably your answer assuming you don't really care about having it mapped to a class. XPath wildcards on node name gives an example of how you'd select multiple items - http://csharp.net-tutorials.com/xml/using-xpath-with-the-xmldocument-class/ gives an example of how it's used in C#.

Another way muight be using XSLT: Using the code: How to apply an XSLT Stylesheet in C# and XSLT like Combining elements from 2 lists in XSLT should get you what you want.

Personally I'd go with whatever makes life easiest since it doesn't look like you really care in this example what the intermediate data structure is.

Upvotes: 1

Related Questions