Develop Reference

How to convert xsd to cs with redundancies? (OTA XML Publication)

I'm trying to create a SOAP 1.2 based C# / WCF interface, that is supposed to handle HTNG / OTA messages. (a communication standard for hotels)
The publication of this OTA standard can be found here: Open Travel Alliance - Specifications
This publication contains a bunch of .xsd files that define all the types that can be passed through such an interface. For example for transferring new reservations to a hotel / system, you can use the OTA_HotelResNotifRQ message, that can contain HotelReservations. The SOAP XML would look something like this:
<soapenv:Body>
<OTA_HotelResNotifRQ EchoToken="1474033560.151702" TimeStamp="2016-09-16T06:46:00-08:00" Version="1.001" xmlns="http://www.opentravel.org/OTA/2003/05" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opentravel.org/OTA/2003/05 NeedToGetThisPathFromIdeas/OTA_HotelResNotifRQ.xsd" ResStatus="Modify">
<POS>
...
</POS>
<HotelReservations>
<HotelReservation CreateDateTime="2015-11-15T10:39:01-08:00" ResStatus="Reserved" LastModifyDateTime="2016-09-16T06:46:00-08:00">
<UniqueID Type="14" ID="133121274"/>
<RoomStays>
<RoomStay MarketCode="Other OTA" SourceOfBusiness="OTA">
...
</RoomStay>
</RoomStays>
</HotelReservation>
</HotelReservations>
</OTA_HotelResNotifRQ>
</soapenv:Body>
The problem is that there are multiple messages, and therefore multiple .xsd definitions using the same elements / classes. For example, for the HotelReservations mentioned above all of the marked messages use it:
All these .xsd files define the same classes, like HotelReservation or RoomStay, etc. and there is an additional .xsd (the HotelReservation, that is not a RQ or an RS) that defines the types used in these messages. What I'm saying is that these schema definitions are very very redundant.
When I try to generate .cs classes from these files, either by using xsd.exe from .NET Framework, or WSCF.Blue I'm faced with all the types getting repeated, for example HotelReservationType is going to be defined by OTA_HotelResRQ.cs, and again by OTA.HotelResNotifRQ.cs, and again by etc. This of course leads to a useless code and to Visual Studio yelling "ambigious reference" all over the place like crazy.
How can I convert these .xsd definitions to .cs classes without redundancy, having all types defined only once? Is there a tool that can do this or did Open Travel Alliance really mess up their publications and I'm pretty much screwed?

You need to create a schema file that includes/imports all the ones you need, then generate the code from that, have a look at Working with multiple XML schemas.
Also have a look at Liquid XML Data Binder if xsd.exe doesn't turn out the kind output you want.

The xsd.exe generated C# class from the W3C XMLschema.xsd (the schema for xsd validation) is not accepted by the C# XmlSerializer

The utility 'xsd.exe' will generate c# class source code that corresponds in various ways to the information in an xsd schema file.
So, I download the schema file 'XMLSchema.xsd' located at "http://www.w3.org/2001/XMLSchema" -- this is the schema for the xsd files themselves.
I generate the C# class corresponding to the 'schema for schemas', using:
xsd.exe /classes /namespace:w3c XMLSchema.xsd
So far so good. I get a file 'XMLSchema.cs' containing a C# class 'schema', and other stuff, in namespace 'w3c' which I proceed to add to a C# project which also contains the following:
try
{
XmlSerializer loader = new XmlSerializer(typeof(w3c.schema));
//never here!! previous line throws!
FileStream fs = new FileStream(
#"M:\src\Interfaces\MyClass1.xsd", FileMode.Open, FileAccess.Read
);
object fromXml = loader.Deserialize(fs);
w3c.schema MyClass1Schema = (w3c.schema)fromXml;
}
catch(Exception e)
{
}
Unfortunately, it throws the following error on the first line of the try block:
The XML element 'annotation' from
namespace
'http://www.w3.org/2001/XMLSchema' is
already present in the current scope.
Use XML attributes to specify another
XML name or namespace for the element.
Has anyone experienced this error?
I would rather not make any modification to the generated file 'XMLSchema.cs'.
I have also (originally) tried:
xsd /classes XMLSchema.xsd
(and no namespacing in the C# test code) with the same result.

I'm going to guess that the problem has nothing to do with .NET namespaces, as you guessed with your second command, but with XML namespaces.
The problem it appears you're having is that the XSD file defines a namespace (likely, xsd) that the XML Serializer already uses (for, surprise surprise, the XSD for the XSD).
I am not sure what the XML spec says for two equivalent namespaces with different identifiers, but the proper way to resolve this would be to change the namespace of your input XSD file. Of course, this will render it invalid, but it would stop XmlSerializer from throwing, I think.

I believe you cannot use namespace in typeof(), instead put the name of the object (instance of class) that you are trying to serialize.

XmlSerializer.Deserialize - ignore unnecessary elements?

I've got an XSD schema which I've generated a class for using xsd.exe, and I'm trying to use XmlSerializer.Deserialize to create an instance of that class from an XML file that is supposed to conform to the XSD schema. Unfortunately the XML file has some extra elements that the schema is not expecting, which causes a System.InvalidOperationException to be thrown from Deserialize.
I've tried adding <xs:any> elements to my schema but this doesn't seem to make any difference.
My question is: is there any way to get XmlSerializer.Deserialize to ignore these extra elements?

I usually add extra properties or fields to all entity classes to pick up extra elements and attributes, looking something like the code below:
[XmlAnyAttribute]
public XmlAttribute[] AnyAttributes;
[XmlAnyElement]
public XmlElement[] AnyElements;
Depending on the complexity of your generated code, you may not find hand-inserting this code on every entity appealing. Perhaps only-slightly-less-tedious is defining these attributes in a base class and ensuring all entities inherit the base.
To give fair attribution, I was first introduced to this pattern when reading the source code for DasBlog.

I don't think there is an option to do this. You either have to fix the schema or manually modify the code generated by xsd.exe to allow the XML to be deserialized. You can also try to open the XML document + schema in Visual Studio or any other XML editor with schema support to either fix the schema or the XML document.

Fill class properties generated from XSD.exe

OK, I generated C# classes from my huge XSD file. Now I have a set of C# classes, XSD schema and actual XML data. Is there an automatic or semi-automatic way to fill these class instances with XML data that I have?
Thank you.

If you have used xsd.exe to generate the classes, then XmlSerializer should do the job...
XmlSerializer ser = new XmlSerializer(typeof(RootType));
RootType type = (RootType) ser.Deserialize(source)

You use the xml serialization/deserialization to export/import data to xml. Take a look at the XmlSerializer class. An example is on the msdn page.

How do I map XML to C# objects

I have an XML that I want to load to objects, manipulate those objects (set values, read values) and then save those XMLs back.
It is important for me to have the XML in the structure (xsd) that I created.
One way to do that is to write my own serializer, but is there a built in support for it or open source in C# that I can use?

You can generate serializable C# classes from a schema (xsd) using xsd.exe:
xsd.exe dependency1.xsd dependency2.xsd schema.xsd /out:outputDir
If the schema has dependencies (included/imported schemas), they must all be included on the same command line.

This code (C# DotNet 1.0 onwards) works quite well to serialize most objects to XML. (and back)
It does not work for objects containing ArrayLists, and if possible stick to using only Arrays
using System;
using System.IO;
using System.Text;
using System.Xml.Serialization;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
public static string Serialize(object objectToSerialize)
{
MemoryStream mem = new MemoryStream();
XmlSerializer ser = new XmlSerializer(objectToSerialize.GetType());
ser.Serialize(mem, objectToSerialize);
ASCIIEncoding ascii = new ASCIIEncoding();
return ascii.GetString(mem.ToArray());
}
public static object Deserialize(Type typeToDeserialize, string xmlString)
{
byte[] bytes = Encoding.UTF8.GetBytes(xmlString);
MemoryStream mem = new MemoryStream(bytes);
XmlSerializer ser = new XmlSerializer(typeToDeserialize);
return ser.Deserialize(mem);
}

LINQ to XML is very powerful if you're using .net 3.5, LINQ to XSD may be useful to you too!

Use xsd.exe command line program that comes with visual studio to create class files that you can use in your project/solution, and the System.Xml.Serialization namespace (specifically, the XmlSerializer class) to serialize/deserialze those classes to and from disk.

using System.Xml.Serialization;
this namespace has all the attributes you'll need if you want to map your xml to any random object. Alternatively you can use the xsd.exe tool
xsd file.xsd {/classes | /dataset} [/element:element]
[/language:language] [/namespace:namespace]
[/outputdir:directory] [URI:uri]
which will take your xsd files and create c# or vb.net classes out of them.
http://msdn.microsoft.com/en-us/library/x6c1kb0s(VS.71).aspx

I agree xsd is really crap... But they made another version that hardly anyone knows about. Its called xsd object generator. Its the next version and has way more options. It generates files from XSD and works fantastic. If you have a schema generator like XML spy; create an xsd from your xml and use this tool. I have created very very complex classes using this tool.
Then create partial classes for extra properties\methods etc, then when you update your schema you just regen your classes and any edits persist in your partial classes.
http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=7075

xsd.exe from Microsoft has a lot of bugs :|
Try this open source pearl http://xsd2code.codeplex.com/

We have created a framework which can auto-generate C# classes out of your XML. Its a visual item template to which you pass your XML and the classes are generated automatically in your project. Using these classes you can create/read/write your XML.
Check this link for the framework and Visual C# item template: click here

I'll bet NetDataContractSerializer can do what you want.