Develop Reference

XML - Serialize class - Some questions

I have the idea of serializing the properties of a class to a XML-file and then upload this file to a server. This is because I want to download this file again and read out the serialized content.
So a structure like this:
File exists (myfile.xml) -> Serialize data from a class (myclass.cs) to the file -> Upload the file.
Now the content could look something like this:
<?xml version="1.0"?>
-<MyClass xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<SomeProperty>0.1.0.0</SomeProperty>
<SomePropertiesChild>Test</SomePropertiesChild>
</MyClass>
Well, so this is not the problem, I have built a class to serialize the data to the file, so that it looks like above.
The problem now is, that I do not know how to go on. I want that the next time new data will be serialized like that, but it should be attached to that XML-file, not a new one.
So I download this file and then serialize new data as attachment to it, so that it will look the following:
<?xml version="1.0"?>
-<MyClass xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<SomeProperty>0.1.0.0</SomeProperty>
<SomePropertiesChild>Test</SomePropertiesChild>
<!-- This is the part that should be attached -->
<SomeProperty>0.2.0.0</SomeProperty>
<SomePropertiesChild>Test2</SomePropertiesChild>
</MyClass>
And this should be repeated as many times as I want: download file, serialize new data and attach it to this one, then upload it again.
Now, the second point is, that I want to read this out.
For that I use the XML-class, too. For the type param for the type that the data should be serialized to, I set the class that contains the properties.
But now, I have more nodes of the same name in my XML like above. I want to separate this now.
So, not only that one class, but for each node with the same name a new class.
To show you that a bit clearer:
In the XML we have the first pair (SomeProperty, SomePropertiesChild).
This one should be deserialized to myclass.cs now, which contains the right properties for the XML-nodes. Example:
public class MyClass
{
public Version SomeProperty {get; set;}
public string SomeProeprtiesChild {get; set;}
}
And then the first XML-pair should be deserialized to that class.
But I want to do this for each XML-"pair" in my XML-file, but I can't get a right structure in my head.
Should I make a List here or how should I do that?
I really hope I could explain it a bit clearly, it is very difficult to explain.
Also I do not know how to do this with the attaching. Any tips?
If you have questions, ask!

What you are looking for is not simply serialization. You want to serialize the same object more than once right?
A possible solution is to serialize a List<MyClass> and append new instances to the list if the file exists.

In short, there is no built-in way to do what it is you are looking for. However, that doesn't mean it can't be done...
The simplest, and closest built-in, way would be to maintain a List<MyClass> which you update whenever you upload/download etc. and serialize. However, this wouldn't get the exact XML you want, this would produce something along the lines of
<ListOfMyClass>
<MyClass>
<Property>1</Property>
...
</MyClass>
<MyClass>
<Property>2</Property>
...
</MyClass>
</ListOfMyClass>
The more complex approach would be to have MyClass implement IXmlSerializable and override the behaviour of WriteXml/ReadXml to handle your custom XML format.

Asp.net XML to objects

I have a XML file, with a structure like
<items>
<item>
<someDetail>
A value here
</someDetail>
</item>
<item>
<someDetail>
Another value here
</someDetail>
</item>
</items>
With multiple items in it.
I want to deserialize the XML on session start ideally, to turn the XML data to objects based on a class (c# asp.net 4)
I have tried several ways with either no success, or a solution which seems clunky and inelegant.
What would people suggest?
I have tried using the xsd.exe tool, and have tried with the xml reader class, as well as usin XElement class to loop through the xml and then create new someObject(props).
These maybe the best and/or only way, but with it being so easy for database sources using the entities framework, I wondered if there was a similar way to do the same but from a xml source.

The best way to deserialize XML it to create a class that corresponds to the XML structure into which the XML data will deserialize.
The latest serialization technology uses Data Contracts and the DataContractSerializer.
You decorate the class I mentioned above with DataMember and DataItem attributes and user the serializer to deserialize.

I'd use directly the .NET XML serialization - classes declarations:
public class Item {
[XmlElement("someDetail")]
public string SomeDetail;
} // class Item
[XmlRoot("items")]
public class MyData {
[XmlElement("item")]
public List<Item> Items;
public static MyData Deserialize(Stream source)
{
XmlSerializer serializer = new XmlSerializer(typeof(MyData));
return serializer.Deserialize(source) as MyData;
} // Deserialize
} // class MyData
and then to read the XML:
using (FileStream fs = new FileStream(#"c:\temp\items.xml", FileMode.Open, FileAccess.Read)) {
MyData myData = MyData.Deserialize(fs);
}

I've concluded is there is not simple unified mechanism (probably due to the inherent complexities involved with non trivial cases - this question always crops up in the context of simple scenarios like your example xml).
Xml serialization is pretty easy to use. For your example, you would just have to create a class to contain a items and another class for the actual item. You might have to apply some attributes to get everything to work correctly, but the coding will not be much. Then it's as easy as -
var serializer = new XmlSerializer(typeof(ItemsContainer));
var items = serializer.Deserialize(...) as ItemsContainer;
Datasets are sometimes considered "yesterday tech" but I use them when they solve the problem well, and you can leverage the designer. The generated code is not pretty but the bottom line is you can persist to a database via the auto generated adapters and to XML using a method right on the data set. You can read it in this way as well.
XSD.exe isn't that bad once you get used to it. I printed the help to a text file and included it in my solutions for a while. When you use the /c option to create classes, you get clean code that can be used with the XmlSerialzier.
Visual Studio 2010 (maybe other versions too) has an XML menu which appears when you have an Xml file open and from that you can also generate an XSD from sample Xml. So in a couple of steps you could take your example xml and generate the XSD, then run it through XSD.exe and use the generated classes with a couple of lines XmlSerializer code... it feels like a lot of machinations but you get used to it.

Serialize an object to XML Element (c#)

[System.Xml.Serialization.XmlRootAttribute("player", IsNullable = false)]
public class Player
{
...
}
Creating and serializing new Player() whitout setting any properties gives me
the XML Element<player/> but I would like to get <player></player>.

As far as XML is concerned, <player/> is equivalent to <player></player>. See XML spec here related to this.
If you still need to have <player></player> then you are doing something wrong.

I am assuming your problem is when you read an empty node you are crashing. You should always check for empty elements before trying to read any elements/attributes.

They should be considered equivalent values. However, if you need then working with a custom XmlWriter may be your best bet, as described here in the answer to a similar question here:
http://social.msdn.microsoft.com/Forums/en-US/xmlandnetfx/thread/979315cf-6727-4979-a554-316218ab8b24/

Elegant Solution to Parsing XElements in a Namespace

In a project I am working on, I just finished writing an XSD for my XML so other engineers could work on the XML easier. Along with this XSD came XML namespaces. In my current parsing code, I have been using something like this:
XElement element = xmlRoot.Element(XML.ELEMENT_NAME);
With XML being a class full of constants that is used throughout the program for XML input and output. But, now that namespaces are being used, this doesn't work anymore. The obvious, but barely elegant, solution is to go in and make all of the parsing code look like this:
XElement element = xmlRoot.Element(XML.NAMESPACE + XML.ELEMENT_NAME);
Thinking about it more, it would look a lot better to go off and define an extension method to add in this namespace and return the XElement. This idea would get the code looking something like this:
XElement element = xmlRoot.GetMyElement(XML.ELEMENT_NAME);
These ideas are what I have come up with so far to deal with the namespace issue.
Basically, my question here is this:
Is there a better method for parsing XElements with a known, constant namespace? If so, what is it?

Well, no one's provided an alternative, and I've already implemented this in the code. So, I'm going to go ahead and put this in as an answer so I can close this out.
I went ahead and used the extension method that automatically added in the namespace. Note that this only works if you have a constant namespace! Otherwise, you may want to add another argument to your extension method simply to avoid doing the weird namespace concatenation.
public static XElement
GetNamespaceElement(this XElement element, string ns, string name)
{
XNamespace n = new XNamespace();
n.NamespaceName = ns;
return element.Element(n + name);
}

Custom XML Serialization, how to write custom root element?

I'm probably just doing this wrong, i know.
I'm using custom serialization and when the xml is generated it's putting the class name as the root element
Example:
<MyClassName>
<MyIntendedRootNode>
<ObjectType>
<Property1/>
<Property2/>
...
I'm invoking the serialization by calling xmlserializer.Serialize(writer,Me) so I'm sure that has something to do with it.
I've tried putting XMLRoot onto the class, but I think as vb is compiling this partial class with its aspx page, it's either overwriting this property or ignoring it entirely.
Ideally I'd like to just tell it to either throw away everything it has and use a different root element.
Anybody else do this except me?
Thanks

You can use either IXmlSerializable or use the XML attributes. I use XmlSerializer passing the root in the constructor.
var MemoryStream ms;
var customRoot = dataObject as XmlRootAttribute;
var xml = new XmlSerializer(dataObject.GetType(), customRoot);
xml.Serialize(ms, dataObject);

In ASP.NET, the actual class that is loaded is a generated class that inherits from your class. (It turns out--surprisingly--that this generated code is actually separate from the additional generated code that is combined with your code using the partial class technique. The generated class has the same name as the class you are working on, but it is in a different namespace.) Since XmlRoot is not an inherited attribute, the XmlSerializer does not see it.
I don't think there is any solution (other than modify the document after you have generated it).

Are you trying to serialize a codebehind file?
I would suggest writing a model to contain the data that needs to be saved, and then serializing that instead. Then use the appropriate XMLWriter attributes to make sure your root element is correctly named.

Or you could implement IXmlSerializable and have full control over your Xml but its a bit of extra effort just to change a root element name.

You can create a wrapper class and give that wrapper class with the name that you wish to be shown in the xml root.