Develop Reference

Change the way how list is serialized into XML

So, I have a class with a list of objects like this:
public int SourceId { get; set; }
public int TargetId { get; set; }
public List<ExtraParameter> ExtraParameters { get; }
Then, when it is serialized into XML file, the output is like this:
<Connection>
<SourceId>0</SourceId>
<TargetId>1</TargetId>
<ExtraParameters>
<ExtraParameter>
<Input>0</Input>
<Output>1</Output>
<Enabled>true</Enabled>
</ExtraParameter>
<ExtraParameter>
<Input>1</Input>
<Output>0</Output>
<Enabled>true</Enabled>
</ExtraParameter>
</ExtraParameters>
</Connection>
But I need to serialize this array of elements (ExtraParameter) using C#'s XmlSerializer into this form:
<Connection>
<SourceId>0</SourceId>
<TargetId>1</TargetId>
<ExtraParameter>
<Input>0</Input>
<Output>1</Output>
<Enabled>true</Enabled>
</ExtraParameter>
<ExtraParameter>
<Input>1</Input>
<Output>0</Output>
<Enabled>true</Enabled>
</ExtraParameter>
</Connection>
So in other words, can I somehow just list the items in that ExtraParameters-list without having that list in this hierarchy? So it does look like objects in the ExtraParameters are just listed at the end of the TargetID-node.
edit: Yes, I know, this kinda breaks the structure, but this xml file is then deserialized by the next program correctly, and I don't have control over that.

You can do this by adding the XmlElement attribute to the relevant property. Per the docs:
If you apply the XmlElementAttribute to a field or property that returns an array, the items in the array are encoded as a sequence of XML elements.
[XmlElement("ExtraParameter")]
public List<ExtraParameter> ExtraParameters { get; }
You could also change the property name rather than adding a value for ElementName to the attribute.
See this fiddle for a working demo.

Attribute format to element in XAML serialization

When I serialize this POCO using XamlServices.Save():
public class GtdConfig
{
public string LocalDbInstanceName { get; set; }
}
The .xaml file will be:
<GtdConfig LocalDbInstanceName="v12.0">
</GtdConfig>
How can I get the file like this:
<GtdConfig>
<GtdConfig.LocalDbInstanceName>v12.0</GtdConfig.LocalDbInstanceName>
</GtdConfig>
For XML serailziation, there are XmlElementAttribute and XmlAttributeAttribute to do this. But I cannot find these attributes in XAML serialization.

Include raw XML when deserializing XML

I have the following XML and classes that are being serialized from it:
<Alerts>
<io id="1">
<name>Foo</name>
<status>Active</status>
</io>
<io id="2">
<name>Bar</name>
<status>Inactive</status>
</io>
</Alerts>
[XmlRoot("Alerts")]
[Serializable]
public class Alerts
{
[XmlElement("io")]
public List<Alert> { get; set; }
}
public class Alert
{
[XmlElement("name")]
public string Name { get; set; }
[XmlElement("status")]
public string Status { get; set; }
}
What I require is a property in my Alert class, that upon deserialization contains the XML of its node. For example, after deserializing the provided XML, I end up with a list of 2 Alert objects. I would need the first alert to have a property that contains this as a string:
<io id="1">
<name>Foo</name>
<status>Active</status>
</io>
Any ideas how I can achieve this?

I think the only way to actually accomplish this is to have a string property, and then in your xml replace the xml reserved characters with entity character references so it doesn't get serialized as xml. So your xml would look something like:
<io id="1">
<name>Foo</name>
<status>Active</status>
<innerAlert>
<io id="3"><name>FooBar</name><status>Inactive</status><innerAlert></innerAlert></io>
</innerAlert>
I still keep going back to my comment and thinking that you might be better off adding a property of type Alert or IEnumerable to your Alert class and let the tree deserialize out all the way down, but maybe that's just not an option to you.

Use the type's root name when serializing collection items

Just a contrived example but I have some classes that I want to control the names of when serialized.
[XmlRoot("item")]
public class ItemWrapper
{
[XmlArray("parts")]
public List<PartWrapper> Parts { get; set; }
}
[XmlRoot("part")]
public class PartWrapper
{
[XmlAttribute("name")]
public string Name { get; set; }
}
Now when I serialize an ItemWrapper that has some Parts, I was expecting each of the PartWrapper items to be serialized using the root name ("part") but it instead uses the type's name (what it would use by default if the XmlRootAttribute wasn't specified).
<item>
<parts>
<PartWrapper name="foo" />
<PartWrapper name="bar" />
</parts>
</item>
Now I know to fix this to get what I want is to add the XmlArrayItemAttribute to the Parts property to specify the name of each of the items but I feel it's redundant. I just wanted to use the name of the type's root as I specified.
[XmlRoot("item")]
public class Item
{
[XmlArray("parts")]
[XmlArrayItem("part", Type=typeof(PartWrapper))]
public List<PartWrapper> Parts { get; set; }
}
Is there a way that I can tell the serializer that I want to use the root name for the collection items? If so, how?
Why wouldn't it just use the root name? Any good reason why it shouldn't?
It was my understanding that the XmlRootAttribute allowed you to name the element exactly like an XmlElementAttribute does, only it had to be applied to the class. I guess I'm mistaken.

From the documentation, it seems that XmlRootAttribute is used only when that element is the root (which is why it works for "item" in your case):
Controls XML serialization of the attribute target as an XML root element
- MSDN
It seems to me like perhaps you want XmlTypeAttribute for things that are not root.

Serialization of array of xml elements already within a xmlAny Element

<Fruits>
<FruitName>Amla</FruitName>
<FruitPrice>10 US DOLLARS</FruitPrice>
<Origin>
<Country>INDIA</Country>
<NativeName>GOOSEBERRY</NativeName>
<Availability>PLENTY</Availability>
</Origin>
<OtherInfo>
<FiberPercentage>1.11</FiberPercentage>
<MagnesiumPercentage>0.02</MagnesiumPercentage>
</OtherInfo>
While De serializing the above XML structure, I use something like,
Xml
XmlElement("FruitsList")]
public List<Fruits> FruitsImport { get; set; }
In Fruits Class, I have something like:
[XmlAnyElement]
public List<XmlElement> FruitElements { get; set; }
[XmlElement("Origin")]
public List<XmlElement> FruitOrigin { get; set; }
[XmlElement("OtherInfo")]
public List<XmlElement> OtherInfo { get; set; }
FruitElement retrieves the FruitName and FruitPrice.
FruitOrigin retrives Country Info alone.
OtherInfo retrives FiberPercentage alone.
Any ideas on how to get all the info under <Origin> and <OtherInfo> tags ?

Because you have elements nested in both <origin> and <otherinfo> tags, you need to define a class for them as well when performing deserialization.
[XmlElement("Origin")]
public List<Origins> FruitOrigin { get; set; }
You would define the origin class the same way as you did for fruit class.
(The skeleton of Origin class would be something as below:
[Serializable]
public class Origin
{
[XmlAnyElement]
public List<XmlElement> OriginElements { get; set; }
}
)

The best way is to write XSD schema for the XML and generate class from XSD schema using XSD.exe, this way you can validate that always XML and class matches to XSD and never have issue with Serialization/ Deserialization.
You can create batch file like below to generate class from xsd schema:
del Configuration.AutoGenerated.cs
"%ProgramFiles%\Microsoft SDKs\Windows\v6.0A\bin\xsd" Test.Configuration.xsd /c /n:Test.Configuration
rename Test_Configuration.cs Configuration.AutoGenerated.cs
pause
You can see more usage examples at above link for XSD.exe.
It will generate partial classes so you can easily extend it further if required.