How can I rename class-names via Xml attributes?
Suppose I have an XML-serializable class called Song:
[Serializable]
class Song
{
public string Artist;
public string SongTitle;
}
In order to save space (and also semi-obfuscate the XML file), I decide to rename the xml elements:
[XmlRoot("g")]
class Song
{
[XmlElement("a")]
public string Artist;
[XmlElement("s")]
开发者_如何学运维 public string SongTitle;
}
This will produce XML output like this:
<Song>
<a>Britney Spears</a>
<s>I Did It Again</s>
</Song>
I want to rename/remap the name of the class/object as well. Say, in the above example, I wish to rename the class Song to g. So that the resultant xml should look like this:
<g>
<a>Britney Spears</a>
<s>I Did It Again</s>
</g>
Is it possible to rename class-names via xml-attributes?
I don't wish to create/traverse the DOM manually, so I was wondering if it could be achieved via a decorator.
I'm actually serializing a list of Song objects in the XML.
Here's the serialization code:
public static bool SaveSongs(List<Song> songs)
{
XmlSerializer serializer = new XmlSerializer(typeof(List<Song>));
using (TextWriter textWriter = new StreamWriter("filename"))
{
serializer.Serialize(textWriter, songs);
}
}
And here's the XML output:
<?xml version="1.0" encoding="utf-8"?>
<ArrayOfSong>
<Song>
<a>Britney Spears</a>
<s>Oops! I Did It Again</s>
</Song>
<Song>
<a>Rihanna</a>
<s>A Girl Like Me</s>
</Song>
</ArrayOfSong>
Apparently, the XmlRoot() attribute doesn't rename the object in a list context.
Am I missing something?
Solution: Use [XmlType(TypeName="g")]
XmlRoot only works with XML root nodes as per the documentation (and what you would expect, given its name includes root)!
I was unable to get any of the other answers to work so kept digging...
Instead I found that the XmlTypeAttribute (i.e. [XmlType]
) and its TypeName property do a similar job for non-root classes/objects.
e.g.
[XmlType(TypeName="g")]
class Song
{
public string Artist;
public string SongTitle;
}
Assuming you apply it to the other classes e.g.:
[XmlType(TypeName="a")]
class Artist
{
.....
}
[XmlType(TypeName="s")]
class SongTitle
{
.....
}
This will output the following exactly as required in the question:
<g>
<a>Britney Spears</a>
<s>I Did It Again</s>
</g>
I have used this in several production projects and found no problems with it.
Checkout the XmlRoot attribute.
Documentation can be found here: http://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlrootattribute(v=VS.90).aspx
[XmlRoot(Namespace = "www.contoso.com",
ElementName = "MyGroupName",
DataType = "string",
IsNullable=true)]
public class Group
UPDATE: Just tried and it works perfectly on VS 2008. This code:
[XmlRoot(ElementName = "sgr")]
public class SongGroup
{
public SongGroup()
{
this.Songs = new List<Song>();
}
[XmlElement(ElementName = "sgs")]
public List<Song> Songs { get; set; }
}
[XmlRoot(ElementName = "g")]
public class Song
{
[XmlElement("a")]
public string Artist { get; set; }
[XmlElement("s")]
public string SongTitle { get; set; }
}
Outputs:
<?xml version="1.0" encoding="utf-8"?>
<sgr xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www
.w3.org/2001/XMLSchema">
<sgs>
<a>A1</a>
<s>S1</s>
</sgs>
<sgs>
<a>A2</a>
<s>S2</s>
</sgs>
</sgr>
If this is the root element of the document, you can use [XmlRoot("g")].
Here is my updated response based on your clarification. The degree of control you are asking for is not possible without a wrapping class. This example uses a SongGroup
class to wrap the list so that you can give alternate names to the items within.
using System;
using System.Collections.Generic;
using System.IO;
using System.Xml.Serialization;
public class SongGroup
{
public SongGroup()
{
this.Songs = new List<Song>();
}
[XmlArrayItem("g", typeof(Song))]
public List<Song> Songs { get; set; }
}
public class Song
{
public Song()
{
}
[XmlElement("a")]
public string Artist { get; set; }
[XmlElement("s")]
public string SongTitle { get; set; }
}
internal class Test
{
private static void Main()
{
XmlSerializer serializer = new XmlSerializer(typeof(SongGroup));
SongGroup group = new SongGroup();
group.Songs.Add(new Song() { Artist = "A1", SongTitle = "S1" });
group.Songs.Add(new Song() { Artist = "A2", SongTitle = "S2" });
using (Stream stream = new MemoryStream())
using (StreamWriter writer = new StreamWriter(stream))
{
serializer.Serialize(writer, group);
stream.Seek(0, SeekOrigin.Begin);
using (StreamReader reader = new StreamReader(stream))
{
Console.WriteLine(reader.ReadToEnd());
}
}
}
}
This has the side effect of generating one more inner element representing the list itself. On my system, the output looks like this:
<?xml version="1.0" encoding="utf-8"?>
<SongGroup xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<Songs>
<g>
<a>A1</a>
<s>S1</s>
</g>
<g>
<a>A2</a>
<s>S2</s>
</g>
</Songs>
</SongGroup>
Use XmlElementAttribute: http://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlrootattribute.aspx
[Serializable]
[XmlRoot(ElementName="g")]
class Song
{
public string Artist;
public string SongTitle;
}
should work.
[XmlRoot("g")]
class Song
{
}
Should do the trick
精彩评论