How to deserialize two different xmls files into two different class-objects in C#? - c#-2.0

Question

Suppose I have two different xml files as embedded-resource in a same assembly:
x.xml
<car brand="Hummer">
<type ... />
<chasis ... />
</car>
y.xml
<shark species="HammerHead">
<color ... />
<maxLen .... />
</shark>
And I have two classes Car.cs and Shark.cs to help to deserialize them.
What would be the technique to deserialize them into two different and separate objects?
The following code can handle only one type at a time. Isn't it?
string[] manifestResourceNames = assembly.GetManifestResourceNames();
foreach (string mrn in manifestResourceNames)
{
Stream stream = assembly.GetManifestResourceStream(mrn);
XmlSerializer serializer = new XmlSerializer(typeof(Car));
Car car = (Car)serializer.Deserialize(stream);
.... .... ....
}
And, when this code will encounter a Shark-class, it will generate an exception.

Answer 1

For the system to be reliable in any way you need to namespace your XML (you should always be namespacing XML anyway - but I'll save you the rant). Therefore:
<car xmlns="http://schemas.cars.org/car" brand="Hummer">
<type /> <chassis />
</car>
<shark xmlns="http://schemas.ocenia.org/predator">
<lazer-beams>1</lazer-beams>
<awesome>Hell yeah.</awesome>
</shark>
Your C# XML serialization attributes would then become:
[XmlRoot("Car", Namespace=CarNamespaceUri)]
public class Car
{
public const string CarNamespaceUri = "http://schemas.cars.org/car";
// ...
}
Following this you would write something along the lines of a XmlSerializerManager. This would maintain an internal Dictionary<Tuple<string, string>, XmlSerializer> - which you can populate via reflection (look for all types with a XmlRootAttribute applied and create the tuple according to Namespace, LocalName and instantiate the XmlSerializer for that type). This would probably be a static class.
To deserialize any element you simply need to look up its Name and Namespace in the dictionary to retrieve the XmlSerializer instance. For example:
public static T Deserialize<T>(XElement element)
{
return (T)Deserialize(element);
}
public static object Deserialize(XElement element)
{
// Remember to do more elaborate checks etc.
using(var r = element.CreateReader())
{
return _serializers[Tuple.Create(element.Name.NamespaceName, element.Name.LocalName)].Deserialize(r);
}
}

Answer 2

Have a look at the XmlSerializer class. From MSDN:
Serializes and deserializes objects into and from XML documents. The
XmlSerializer enables you to control how objects are encoded into XML.
If you class structure doesn't not exactly match the ML given, i.e. there isn't a correlation between property names and XML elements, you will have to use attributes to provide a suitable mapping.
Regarding your code above, an XmlSerializer instance is constructed such that it serializes / de-serializes a single type. You need to create separate instances of this class, one for car one for shark.

Answer 3

your code can handle one class only.
i used this link to learn about XMLserializer. here you can find some nice examples. in the last example this code appears:
static List<Movie> DeserializeFromXML()
{
XmlSerializer deserializer = new XmlSerializer(typeof(List<Movie>));
TextReader textReader = new StreamReader(#"C:\movie.xml");
List<Movie> movies;
movies = (List<Movie>)deserializer.Deserialize(textReader);
textReader.Close();
return movies;
}
you can rebuild it to use your .xml files in this matter:
static List<Car> DeserializeCar()
{
XmlSerializer deserializer = new XmlSerializer(typeof(List<Car>));
TextReader textReader = new StreamReader("./car.xml");
List<Car> cars;
cars= (List<Car>)deserializer.Deserialize(textReader);
textReader.Close();
return cars;
}
static List<Car> DeserializeShark()
{
XmlSerializer deserializer = new XmlSerializer(typeof(List<Shark>));
TextReader textReader = new StreamReader("./shark.xml");
List<Shark> shark;
shark= (List<Shark>)deserializer.Deserialize(textReader);
textReader.Close();
return shark;
}
by calling these 2 function you can get both classes

Answer 4

I would create an abstract base class like the following
public abstract class Model<T>
{
public static T GetFromXml(String path)
{
if (!File.Exists(path))
return null;
var serializer = new XmlSerializer(typeof(T));
return (T)serializer.Deserialize(File.OpenRead(path));
}
}
public class Car : Model<Car>
{
public String Brand { get; set; }
public String Type { get; set; }
public String Chasis { get; set; }
}
public class Shark : Model<Shark>
{
public String Species { get; set; }
public String Color { get; set; }
public long MaxLength { get; set; }
}
You could easily access the static method from any subclass
Car myCar = Car.GetFromXml("a.xml");
Shark greatWhite = Shark.GetFromXml("b.xml");
Hope that's what you're lookin for.
Thorsten