We Keep Coding

How to change schemas in an XML document with c#

I have an XML-file that looks like this:
<?xml version="1.0"?>
<paxml xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<header>
<format>LÖNIN</format>
<version>2</version>
</header>
<tidtransaktioner>
<tidtrans anstid="1418">
<tidkod>SJK</tidkod>
<datum>2022-02-02T15:20:00</datum>
<timmar>0</timmar>
</tidtrans>
<tidtrans anstid="1418">
<tidkod>SJK</tidkod>
<datum>2022-02-21T10:40:00</datum>
<timmar>0</timmar>
</tidtrans>
</tidtransaktioner>
</paxml>
I need to change the second line:
<paxml xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
To be like this:
<paxml xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.paxml.se/2.0/paxml.xsd">
Does anyone have any idea how this can be done?
Here is my class for the XML:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
namespace Logic.Shared.Models
{
// using System.Xml.Serialization;
// XmlSerializer serializer = new XmlSerializer(typeof(Paxml));
[XmlRoot(ElementName = "header", Namespace = "")]
public class Header
{
[XmlElement(ElementName = "format", Namespace = "")]
public string Format { get; set; }
[XmlElement(ElementName = "version", Namespace = "")]
public double Version { get; set; }
}
[XmlRoot(ElementName = "dimension", Namespace = "")]
public class Dimension
{
[XmlAttribute(AttributeName = "dim", Namespace = "")]
public int Dim { get; set; }
[XmlAttribute(AttributeName = "namn", Namespace = "")]
public string Namn { get; set; }
}
[XmlRoot(ElementName = "dimensioner", Namespace = "")]
public class Dimensioner
{
[XmlElement(ElementName = "dimension", Namespace = "")]
public List<Dimension> Dimension { get; set; }
}
[XmlRoot(ElementName = "resultatenhet", Namespace = "")]
public class Resultatenhet
{
[XmlAttribute(AttributeName = "dim", Namespace = "")]
public int Dim { get; set; }
[XmlAttribute(AttributeName = "id", Namespace = "")]
public int Id { get; set; }
[XmlAttribute(AttributeName = "namn", Namespace = "")]
public int Namn { get; set; }
}
[XmlRoot(ElementName = "resultatenheter", Namespace = "")]
public class Resultatenheter
{
[XmlElement(ElementName = "resultatenhet", Namespace = "")]
public List<Resultatenhet> Resultatenhet { get; set; }
}
[XmlRoot(ElementName = "tidtrans", Namespace = "")]
public class Tidtrans
{
[XmlElement(ElementName = "tidkod", Namespace = "")]
public string Tidkod { get; set; }
[XmlElement(ElementName = "datum", Namespace = "")]
public DateTime Datum { get; set; }
[XmlElement(ElementName = "timmar", Namespace = "")]
public double Timmar { get; set; }
[XmlAttribute(AttributeName = "anstid", Namespace = "")]
public int Anstid { get; set; }
[XmlText]
public string Text { get; set; }
[XmlElement(ElementName = "resenheter", Namespace = "")]
public Resenheter Resenheter { get; set; }
}
[XmlRoot(ElementName = "resenhet", Namespace = "")]
public class Resenhet
{
[XmlAttribute(AttributeName = "dim", Namespace = "")]
public int Dim { get; set; }
[XmlAttribute(AttributeName = "id", Namespace = "")]
public int Id { get; set; }
}
[XmlRoot(ElementName = "resenheter", Namespace = "")]
public class Resenheter
{
[XmlElement(ElementName = "resenhet", Namespace = "")]
public List<Resenhet> Resenhet { get; set; }
}
[XmlRoot(ElementName = "tidtransaktioner", Namespace = "")]
public class Tidtransaktioner
{
[XmlElement(ElementName = "tidtrans", Namespace = "")]
public List<Tidtrans> Tidtrans { get; set; }
}
[XmlRoot(ElementName = "dag", Namespace = "")]
public class Dag
{
[XmlAttribute(AttributeName = "datum", Namespace = "")]
public DateTime Datum { get; set; }
[XmlAttribute(AttributeName = "timmar", Namespace = "")]
public double Timmar { get; set; }
}
[XmlRoot(ElementName = "schema", Namespace = "")]
public class Schema
{
[XmlElement(ElementName = "dag", Namespace = "")]
public List<Dag> Dag { get; set; }
[XmlAttribute(AttributeName = "anstid", Namespace = "")]
public int Anstid { get; set; }
}
[XmlRoot(ElementName = "schematransaktioner", Namespace = "")]
public class Schematransaktioner
{
[XmlElement(ElementName = "schema", Namespace = "")]
public List<Schema> Schema { get; set; }
}
[XmlRoot(ElementName = "paxml", Namespace = "")]
public class Paxml
{
[XmlElement(ElementName = "header", Namespace = "")]
public Header Header { get; set; }
[XmlElement(ElementName = "dimensioner", Namespace = "")]
public Dimensioner Dimensioner { get; set; }
[XmlElement(ElementName = "resultatenheter", Namespace = "")]
public Resultatenheter Resultatenheter { get; set; }
[XmlElement(ElementName = "tidtransaktioner", Namespace = "")]
public Tidtransaktioner Tidtransaktioner { get; set; }
[XmlElement(ElementName = "schematransaktioner", Namespace = "")]
public Schematransaktioner Schematransaktioner { get; set; }
[XmlAttribute(AttributeName = "xsi", Namespace = "http://www.w3.org/2001/XMLSchema-instance")]
public string Xsi { get; set; }
[XmlAttribute(AttributeName = "noNamespaceSchemaLocation", Namespace = "http://www.paxml.se/2.0/paxml.xsd")]
public string NoNamespaceSchemaLocation { get; set; }
[XmlText]
public string Text { get; set; }
}
}
This class is generated by an XML-file generator. As you can see I have been trying to add XML attributes to manually change the namespaces.
And this is the class for the logic:
using Logic.Mobigo.Services;
using Logic.Shared.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
namespace Logic.Services
{
public class XMLService
{
private readonly MobigoTimeService _mobigoTimeService;
private readonly MobigoUserService _mobigoUserService;
public XMLService(MobigoTimeService mobigoTimeService, MobigoUserService mobigoUserService)
{
_mobigoTimeService = mobigoTimeService;
_mobigoUserService = mobigoUserService;
}
public async Task<bool> Xml()
{
var timeRows = await _mobigoTimeService.List();
var xml = new Paxml();
xml.Header = new Header();
xml.Header.Format = "LÖNIN";
xml.Header.Version = 2.0;
var tidTrans = new List<Tidtrans>();
foreach (var timeRow in timeRows)
{
var user = await _mobigoUserService.GetByUserSign(timeRow.UserSign);
;
tidTrans.Add(new Tidtrans
{
Anstid = 1418, //int.Parse(user.EmployeeNr),
Tidkod = "SJK", //timeRow.TimeType.TimeCode,
//hur göra med datum vid månadsöverskridelse????
Datum = timeRow.StopDate,
Timmar = timeRow.TimeAmount,
});
}
xml.Tidtransaktioner = new Tidtransaktioner
{
Tidtrans = tidTrans,
};
var writer = new XmlSerializer(typeof(Paxml));
var path = "C:\\Work\\Git\\LIM\\PDF\\" + "testfile.xml";
System.IO.FileStream file = System.IO.File.Create(path);
writer.Serialize(file, xml);
file.Close();
return true;
}
}
}

You're not too far off, but you're muddling namespaces and values. You want an attribute called noNamespaceSchemaLocation in the namespace http://www.w3.org/2001/XMLSchema-instance with the value http://www.paxml.se/2.0/paxml.xsd. That would look like this:
[XmlAttribute(AttributeName = "noNamespaceSchemaLocation", Namespace = "http://www.w3.org/2001/XMLSchema-instance")]
public string NoNamespaceSchemaLocation { get; set; } = "http://www.paxml.se/2.0/paxml.xsd";
And the root XML produced would look like this by default:
<paxml xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xsi:noNamespaceSchemaLocation="http://www.paxml.se/2.0/paxml.xsd" />
This is semantically the same as what you require, and shouldn't cause any issues as a result. But if you really want to get rid of the namespace declaration for xsd, you can supply an XmlSerializerNamespaces that only has the namespace you need:
var ns = new XmlSerializerNamespaces();
ns.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance");
var serializer = new XmlSerializer(typeof(Paxml));
serializer.Serialize(file, xml, ns);

C# | How do I change the namespace in an XML document?

So im struggling to change the namespace for specific nodes in an XML.
This is what i want to achieve:
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ns1="http://www.justapage.com/webservices/">
<SOAP-ENV:Body>
<ns1:products_Update>
<ns1:login>
...
</ns1:login>
<ns1:products>
<ns1:product>
...
</ns1:product>
</ns1:products>
</ns1:products_Update>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
But the results always turns out like this:
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ns1="http://www.justapage.com/webservices/">
<SOAP-ENV:Body>
<SOAP-ENV:products_Update>
<SOAP-ENV:login>
...
</SOAP-ENV:login>
<SOAP-ENV:products>
<SOAP-ENV:product>
...
</SOAP-ENV:product>
</SOAP-ENV:products>
</SOAP-ENV:products_Update>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
And this is how i serialize it:
public static async Task<string> SerializeSendMessage<T>(this T toSerialize)
{
string returnString;
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = Encoding.UTF8;
XmlSerializer xsSubmit = new XmlSerializer(typeof(T));
using (StringWriter sw = new StringWriter())
using (XmlWriter writer = XmlWriter.Create(sw))
{
var xmlns = new XmlSerializerNamespaces();
xmlns.Add("soapenv", "http://schemas.xmlsoap.org/soap/envelope/");
xmlns.Add("ns1", "http://www.justapage.com/webservices/");
xsSubmit.Serialize(writer, toSerialize,xmlns);
returnString = sw.ToString(); // Your XML
}
return returnString;
}
The class:
[XmlRoot(ElementName="Envelope",IsNullable = false)]
public class ArticleEnvelope
{
[XmlElement(ElementName = "Body",Namespace = "http://schemas.xmlsoap.org/soap/envelope/")]
public Body Body { get; set; }
[XmlAttribute(AttributeName = "SOAP-ENV")]
public string SOAPENV { get; set; }
[XmlAttribute(AttributeName = "ns1")]
public string Ns1 { get; set; }
[XmlText]
public string Text { get; set; }
}
[XmlRoot(ElementName = "Body")]
public class Body
{
[XmlElement(ElementName = "products_Update")]
public ProductsUpdate ProductsUpdate { get; set; }
}
[XmlRoot(ElementName = "products_Update")]
public class ProductsUpdate
{
[XmlElement(ElementName = "login")]
public Login Login { get; set; }
[XmlElement(ElementName = "products")]
public Products Products { get; set; }
}
[XmlRoot(ElementName = "products")]
public class Products
{
[XmlElement(ElementName = "product")]
public List<Product> Product { get; set; }
}
}
I have tried to find some information about this but with no success and I now hope that someone here can point me into the right direction on how to acheive this.

Try following :
using System;
using System.Xml;
using System.Xml.Serialization;
using System.IO;
using System.Text;
using System.Collections.Generic;
namespace ConsoleApp2
{
class Program
{
static ArticleEnvelope envelope { get; set; }
static void Main(string[] args)
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = Encoding.UTF8;
XmlSerializer xsSubmit = new XmlSerializer(typeof(ArticleEnvelope));
using (StringWriter sw = new StringWriter())
using (XmlWriter writer = XmlWriter.Create(sw))
{
var xmlns = new XmlSerializerNamespaces();
xmlns.Add("SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/");
xmlns.Add("ns1", "http://www.justapage.com/webservices/");
xsSubmit.Serialize(writer, envelope, xmlns);
}
}
[XmlRoot(ElementName = "Envelope", Namespace = "http://schemas.xmlsoap.org/soap/envelope/", IsNullable = false)]
public class ArticleEnvelope
{
[XmlElement(ElementName = "Body", Namespace = "http://schemas.xmlsoap.org/soap/envelope/")]
public Body Body { get; set; }
[XmlText]
public string Text { get; set; }
}
public class Body
{
[XmlElement(ElementName = "products_Update", Namespace = "http://www.justapage.com/webservices/")]
public ProductsUpdate ProductsUpdate { get; set; }
}
public class ProductsUpdate
{
[XmlElement(ElementName = "login", Namespace = "http://www.justapage.com/webservices/")]
public Login Login { get; set; }
[XmlArray(ElementName = "products", Namespace = "http://www.justapage.com/webservices/")]
[XmlArrayItem(ElementName = "product", Namespace = "http://www.justapage.com/webservices/")]
public List<Product> Products { get; set; }
}
public class Login
{
}
public class Product
{
}
}

Failed deserializing xml due to namespaces

I have the following xml that i want to deserialize to a c# class:
<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/" xmlns:tns="http://www.s1.com/info/" xmlns:types="http://www.s1.com/info/" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Header>
<tns:SessionInfo>
<SessionId xsi:type="xsd:string">string</SessionId>
</tns:SessionInfo>
</soap:Header>
<soap:Body soap:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<tns:LoginResponse>
<Result xsi:type="xsd:boolean">boolean</Result>
</tns:LoginResponse>
</soap:Body>
</soap:Envelope>
I am using the following classes in order to deserialize the xml:
public class SessionId
{
[XmlAttribute(AttributeName = "type", Namespace = "http://www.w3.org/2001/XMLSchema-instance")]
public string Type { get; set; }
[XmlText]
public string Text { get; set; }
}
[XmlRoot(ElementName = "SessionInfo", Namespace = "http://www.s1.com/info/")]
public class SessionInfo
{
[XmlElement(ElementName = "SessionId")]
public SessionId SessionId { get; set; }
[XmlAttribute(AttributeName = "id", Namespace = "")]
public string Id { get; set; }
[XmlText]
public string Text { get; set; }
}
[XmlRoot(ElementName = "Header", Namespace = "http://schemas.xmlsoap.org/soap/envelope/")]
public class Header
{
[XmlElement(ElementName = "SessionInfo", Namespace = "http://www.s1.com/info/")]
public SessionInfo SessionInfo { get; set; }
}
[XmlRoot(ElementName = "Result", Namespace = "")]
public class Result
{
[XmlAttribute(AttributeName = "type", Namespace = "http://www.w3.org/2001/XMLSchema-instance")]
public string Type { get; set; }
[XmlText]
public string Text { get; set; }
}
[XmlRoot(ElementName = "LoginResponse", Namespace = "http://www.s1.com/info/")]
public class LoginResponse
{
[XmlElement(ElementName = "Result")]
public Result Result { get; set; }
}
[XmlRoot(ElementName = "Body", Namespace = "http://schemas.xmlsoap.org/soap/envelope/")]
public class Body
{
[XmlElement(ElementName = "LoginResponse", Namespace = "http://www.s1.com/info/")]
public LoginResponse LoginResponse { get; set; }
[XmlAttribute(AttributeName = "encodingStyle", Namespace = "http://schemas.xmlsoap.org/soap/envelope/")]
public string EncodingStyle { get; set; }
[XmlText]
public string Text { get; set; }
}
[XmlRoot(ElementName = "Envelope", Namespace = "http://schemas.xmlsoap.org/soap/envelope/")]
public class Envelope
{
[XmlElement(ElementName = "Header", Namespace = "http://schemas.xmlsoap.org/soap/envelope/")]
public Header Header { get; set; }
[XmlElement(ElementName = "Body", Namespace = "http://schemas.xmlsoap.org/soap/envelope/")]
public Body Body { get; set; }
[XmlAttribute(AttributeName = "xsi", Namespace = "http://www.w3.org/2000/xmlns/")]
public string Xsi { get; set; }
[XmlAttribute(AttributeName = "xsd", Namespace = "http://www.w3.org/2000/xmlns/")]
public string Xsd { get; set; }
[XmlAttribute(AttributeName = "soapenc", Namespace = "http://www.w3.org/2000/xmlns/")]
public string Soapenc { get; set; }
[XmlAttribute(AttributeName = "tns", Namespace = "http://www.w3.org/2000/xmlns/")]
public string Tns { get; set; }
[XmlAttribute(AttributeName = "types", Namespace = "http://www.w3.org/2000/xmlns/")]
public string Types { get; set; }
[XmlAttribute(AttributeName = "soap", Namespace = "http://www.w3.org/2000/xmlns/")]
public string Soap { get; set; }
[XmlText]
public string Text { get; set; }
}
The problem is that the SessionId element is not getting deserialized, I am assuming due to the namespaces mismatch. I tried using an empty string as the namespace but that doesn't work either as it doesn't get recognized during deserialization.
Any insight on the problem is very much appreciated. Thank you!

First, SessionId has the wrong namespace. It inherits this from the parent, you need to explicitly specify that it doesn't have one by setting it to an empty string.
Secondly, the xsi:type has a special meaning, you shouldn't try to deserialise this. It's used to indicate the content type of an element - in this case, string - and will be used by the serialiser. The implication is that this is one of many acceptable types. The simplest way to define this is using object.
Putting those together, this should work:
[XmlElement(ElementName = "SessionId", Namespace = "")]
public object SessionId { get; set; }
SessionId should contain a string object with value string.
I'd also note various other minor things:
You shouldn't specify all the namespace bindings (e.g. Xsd) as part of the model. This is lower level than this model and will be handled by the serialiser.
You only need XmlRoot on the root
You don't need XmlText properties where there isn't any text
You need to make a similar change to above to deserialise Result
ElementName and AttributeName will default to the name of the property, so you don't have to specify these if that's what you want
Taking that into account, this model should work:
public class SessionInfo
{
[XmlElement(Namespace = "")]
public object SessionId { get; set; }
}
public class Header
{
[XmlElement(Namespace = "http://www.s1.com/info/")]
public SessionInfo SessionInfo { get; set; }
}
public class LoginResponse
{
[XmlElement(Namespace = "")]
public object Result { get; set; }
}
public class Body
{
[XmlElement(Namespace = "http://www.s1.com/info/")]
public LoginResponse LoginResponse { get; set; }
[XmlAttribute("encodingStyle", Namespace = "http://schemas.xmlsoap.org/soap/envelope/", Form = XmlSchemaForm.Qualified)]
public string EncodingStyle { get; set; }
}
[XmlRoot(Namespace = "http://schemas.xmlsoap.org/soap/envelope/")]
public class Envelope
{
[XmlElement]
public Header Header { get; set; }
[XmlElement]
public Body Body { get; set; }
}
You can see a working demo here. I've made one change to the source XML - I changed the Result value from boolean to true, else you'll get an exception because boolean isn't a valid value for that type.

Serialize classes to XML with namespaces

I am struggling actually with serializing my classes to the desired XML. I have problems placing the namespaces in the correct way.
here is the needed XML:
<?xml version="1.0" encoding="UTF-8"?> <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:q0="http://abc.def.schema" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<soapenv:Header>
<q0:LoginScopeHeader>
<organizationName>WebService Test Account</organizationName>
</q0:LoginScopeHeader>
<q0:SessionHeader>
<sessionId>00f63ba748474ebba5a5ce0f8fdf7ac4</sessionId>
</q0:SessionHeader>
</soapenv:Header>
<soapenv:Body>
<q0:GroupSet>
<staticGroup>
<number>10000</number>
<name>Gruppe A</name>
<conference>false</conference>
<activated>true</activated>
<personsCounter>0</personsCounter>
<messageName xsi:nil="true"/>
<personNumber xsi:nil="true"/>
</staticGroup>
<staticGroup>
<number>10000</number>
<name>Gruppe A</name>
<conference>false</conference>
<activated>true</activated>
<personsCounter>0</personsCounter>
<messageName xsi:nil="true"/>
<personNumber xsi:nil="true"/>
</staticGroup>
</q0:GroupSet>
</soapenv:Body>
Actually my class representation looks like this:
[XmlRoot(ElementName = "Envelope")]
public class Envelope
{
[XmlElement(ElementName = "Header")]
public Header Header { get; set; }
[XmlElement(ElementName = "Body")]
public Body Body { get; set; }
[XmlAttribute(AttributeName = "soapenv")]
public string Soapenv { get; set; }
[XmlAttribute(AttributeName = "q0")]
public string Q0 { get; set; }
[XmlAttribute(AttributeName = "xsd")]
public string Xsd { get; set; }
[XmlAttribute(AttributeName = "xsi")]
public string Xsi { get; set; }
}
[XmlRoot(ElementName = "LoginScopeHeader")]
public class LoginScopeHeader
{
[XmlElement(ElementName = "organizationName")]
public string OrganizationName { get; set; }
}
[XmlRoot(ElementName = "SessionHeader")]
public class SessionHeader
{
[XmlElement(ElementName = "sessionId")]
public string SessionId { get; set; }
}
[XmlRoot(ElementName = "Header")]
public class Header
{
[XmlElement(ElementName = "LoginScopeHeader")]
public LoginScopeHeader LoginScopeHeader { get; set; }
[XmlElement(ElementName = "SessionHeader")]
public SessionHeader SessionHeader { get; set; }
}
[XmlRoot(ElementName = "Body")]
public class Body
{
[XmlElement(ElementName = "GroupSet")]
public GroupSet GroupSet { get; set; }
}
[XmlRoot(ElementName = "GroupSet")]
public class GroupSet
{
[XmlElement(ElementName = "staticGroup")]
public List<StaticGroup> StaticGroup { get; set; }
}
[XmlRoot(ElementName = "staticGroup")]
public class StaticGroup
{
[XmlElement(ElementName = "number")]
public string Number { get; set; }
[XmlElement(ElementName = "name")]
public string Name { get; set; }
[XmlElement(ElementName = "conference")]
public string Conference { get; set; }
[XmlElement(ElementName = "activated")]
public string Activated { get; set; }
[XmlElement(ElementName = "personsCounter")]
public string PersonsCounter { get; set; }
[XmlElement(ElementName = "messageName")]
public MessageName MessageName { get; set; }
[XmlElement(ElementName = "personNumber")]
public PersonNumber PersonNumber { get; set; }
}
[XmlRoot(ElementName = "messageName")]
public class MessageName
{
[XmlAttribute(AttributeName = "nil")]
public string Nil { get; set; }
}
[XmlRoot(ElementName = "personNumber")]
public class PersonNumber
{
[XmlAttribute(AttributeName = "nil")]
public string Nil { get; set; }
}
And here the extension method for the serialization:
public static string XmlSerialize<T>(this T item, bool removeNamespaces = true)
{
object locker = new object();
XmlSerializerNamespaces xmlns = new XmlSerializerNamespaces();
xmlns.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance");
xmlns.Add("xsd", "http://www.w3.org/2001/XMLSchema");
xmlns.Add("soapenv", "http://schemas.xmlsoap.org/soap/envelope/");
XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.OmitXmlDeclaration = true;
lock (locker)
{
StringBuilder stringBuilder = new StringBuilder();
using (StringWriter stringWriter = new StringWriter(stringBuilder))
{
using (XmlWriter xmlWriter = XmlWriter.Create(stringWriter, settings))
{
if (removeNamespaces)
{
xmlSerializer.Serialize(xmlWriter, item, xmlns);
}
else { xmlSerializer.Serialize(xmlWriter, item); }
return stringBuilder.ToString();
}
}
}
}
I have actually no clue how the get the namespaces serialized like in the above XML.
What do I miss? Any help is highly appreciated

You need to assign your serialisation attributes with the appropriate namespaces. The Envelope, Body and Header elements have the namespace http://schemas.xmlsoap.org/soap/envelope/. So your Envelope class should look like this:
[XmlRoot(ElementName = "Envelope", Namespace = "http://schemas.xmlsoap.org/soap/envelope/")]
public class Envelope
{
[XmlElement(ElementName = "Header")]
public Header Header { get; set; }
[XmlElement(ElementName = "Body")]
public Body Body { get; set; }
}
You have added the namespace prefixes (q0, xsi, xsd) as properties of your Envelope class, this is not necessary so you can remove them.
The other namespace involved is http://abc.def.schema which has the q0 prefix. You should assign that where needed at the top level, for example, in the Body class, it should be assigned to the GroupSet property:
[XmlRoot(ElementName = "Body", Namespace = "http://schemas.xmlsoap.org/soap/envelope/")]
public class Body
{
[XmlElement(ElementName = "GroupSet", Namespace = "http://abc.def.schema")]
public GroupSet GroupSet { get; set; }
}
When you come to serialize, at the moment you are not telling the serializer about the q0 namespace prefix. So you need to add this in your XmlSerialize<T> extension method:
xmlns.Add("q0", "http://abc.def.schema");
Your StaticGroup element does not have a namespace defined in your example XML. So your GroupSet needs to define an empty namespace here:
[XmlRoot(ElementName = "GroupSet", Namespace = "http://abc.def.schema")]
public class GroupSet
{
[XmlElement(ElementName = "staticGroup", Namespace = "")]
public List<StaticGroup> StaticGroup { get; set; }
}

UPDATE_1:
I have added the namespaces as suggested by jdweng like so:
[XmlRoot(ElementName = "Envelope", Namespace = "http://schemas.xmlsoap.org/soap/envelope/")]
public class Envelope
{
[XmlElement(ElementName = "Header")]
public Header Header { get; set; }
[XmlElement(ElementName = "Body")]
public Body Body { get; set; }
[XmlAttribute(AttributeName = "soapenv")]
public string Soapenv { get; set; }
[XmlAttribute(AttributeName = "q0")]
public string Q0 { get; set; }
[XmlAttribute(AttributeName = "xsd")]
public string Xsd { get; set; }
[XmlAttribute(AttributeName = "xsi")]
public string Xsi { get; set; }
}
[XmlRoot(ElementName = "Header", Namespace = http://schemas.xmlsoap.org/soap/envelope/")]
public class Header
{
[XmlElement(ElementName = "LoginScopeHeader")]
public LoginScopeHeader LoginScopeHeader { get; set; }
[XmlElement(ElementName = "SessionHeader")]
public SessionHeader SessionHeader { get; set; }
}
[XmlRoot(ElementName = "Body", Namespace = "http://schemas.xmlsoap.org/soap/envelope/")]
public class Body
{
[XmlElement(ElementName = "PersonSet")]
public PersonSet PersonSet { get; set; }
}
but now I get the following XML:
<soapenv:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
<soapenv:Header>
<soapenv:LoginScopeHeader>
<soapenv:organizationName>Blablabla</soapenv:organizationName>
</soapenv:LoginScopeHeader>
<soapenv:SessionHeader>
<soapenv:sessionId>654654654654654654654</soapenv:sessionId>
</soapenv:SessionHeader>
</soapenv:Header>
<soapenv:Body>
<soapenv:PersonSet>
<soapenv:elements>
<soapenv:active>true</soapenv:active>
<soapenv:number>321321321</soapenv:number>
<soapenv:name1>John</soapenv:name1>
<soapenv:name2>Doe</soapenv:name2>
<soapenv:language>DE</soapenv:language>
<soapenv:extra />
<soapenv:remarks>remarks</soapenv:remarks>
<soapenv:pin>65454</soapenv:pin>
<soapenv:onDutyManagement>false</soapenv:onDutyManagement>
<soapenv:onDutyManagementAutomaticLogoutDuration>0</soapenv:onDutyManagementAutomaticLogoutDuration>
<soapenv:onDutyManagementNotification>false</soapenv:onDutyManagementNotification>
<soapenv:contactDataManager>false</soapenv:contactDataManager>
<soapenv:contactDataManagedBy nil="1" />
<soapenv:caseManagerAccessMode>NO_ACCESS</soapenv:caseManagerAccessMode>
<soapenv:plannedPeriodsOfAbsence nil="1" />
<soapenv:groups>
<soapenv:elements>
<soapenv:active>true</soapenv:active>
<soapenv:conference_moderator>false</soapenv:conference_moderator>
<soapenv:time_offset>0</soapenv:time_offset>
<soapenv:groupNumber>123456</soapenv:groupNumber>
</soapenv:elements>
</soapenv:groups>
<soapenv:devices>
<soapenv:elements>
<soapenv:callingNumberOrEmail>s_c#gmx.ch</soapenv:callingNumberOrEmail>
<soapenv:prio_working_hours>1</soapenv:prio_working_hours>
<soapenv:prio_non_working_hours>0</soapenv:prio_non_working_hours>
<soapenv:dtmfExtensionNumber />
<soapenv:deviceName>EMail Privat</soapenv:deviceName>
</soapenv:elements>
</soapenv:devices>
</soapenv:elements>
</soapenv:PersonSet>
</soapenv:Body>
</soapenv:Envelope>

Error when Deserializing XML into c# class derived from xsd.exe with namespace

I will start off with I have read all of the other answers to this question and all of them (albeit good solutions) did not work in my case
I created a c# class from my xsd file with
xsd.exe /c neworder.xsd
It generated a class of 7000+ lines so I'll post relevant parts of it.
using System;
using System.Diagnostics;
using System.Xml.Serialization;
using System.Collections;
using System.Xml.Schema;
using System.ComponentModel;
using System.IO;
using System.Text;
using System.Xml;
using System.Collections.Generic;
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Xml", "4.0.30319.34234")]
[System.SerializableAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType = true, Namespace = "http://www.foo.com/schemas/w/v1.0")]
[System.Xml.Serialization.XmlRootAttribute("new-order", Namespace = "http://www.foo.com/schemas/w/v1.0")]
public partial class neworder
{
private List<customertype> customersField;
private string suppliercodeField;
private string versionField;
private static System.Xml.Serialization.XmlSerializer serializer;
public neworder()
{
this.customersField = new List<customertype>();
}
[System.Xml.Serialization.XmlArrayAttribute(Order = 0)]
[System.Xml.Serialization.XmlArrayItemAttribute("customer",IsNullable = false)]
public List<customertype> customers
{
get
{
return this.customersField;
}
set
{
this.customersField = value;
}
}
[System.Xml.Serialization.XmlAttributeAttribute("supplier-code")]
public string suppliercode
{
get
{
return this.suppliercodeField;
}
set
{
this.suppliercodeField = value;
}
}
[System.Xml.Serialization.XmlAttributeAttribute("version")]
public string version
{
get
{
return this.versionField;
}
set
{
this.versionField = value;
}
}
private static System.Xml.Serialization.XmlSerializer Serializer
{
get
{
if ((serializer == null))
{
serializer = new System.Xml.Serialization.XmlSerializer(typeof(neworder));
}
return serializer;
}
}
public static neworder Deserialize(string xml)
{
System.IO.StringReader stringReader = null;
try
{
stringReader = new System.IO.StringReader(xml);
return ((neworder)(Serializer.Deserialize(System.Xml.XmlReader.Create(stringReader))));
}
finally
{
if ((stringReader != null))
{
stringReader.Dispose();
}
}
}
That is just a small snippet, the rest isn't that important right now as I feel like if this gets solved, I can solve the rest.
This is the beginning part of the XML file
<new-order xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.foo.com/schema/w/v1.0" version="1.0" supplier-code="FAKECODE" schemaLocation="http://www.foo.com/schemas/w/v1.0/TransmissionEnvelope.xsd">
<customers>
<customer w-number="123456" customer-number="12345-12345">
<client-info>
<client-name>John Doe</client-name>
<w-id>433348</w-id>
</client-info>
<transferee-name>
<first>John</first>
<last>Doe</last>
</transferee-name>
<spouse-name>
<first />
<last />
</spouse-name>
<o-address>
<street1>123 Fake st</street1>
<city>Fakeville</city>
<state>CA</state>
<postal-code>90210</postal-code>
<country>USA</country>
</o-address>
<d-address>
<street1 />
<city>harbour</city>
<state>VA</state>
<postal-code>55555</postal-code>
<country>USA</country>
</d-address>
<contact-info>
<phone>
<phone-type>CELL</phone-type>
<phone-number>555-555-5555</phone-number>
</phone>
<phone>
<phone-type>HOME</phone-type>
<phone-number>555-555-5555</phone-number>
</phone>
<phone>
<phone-type>WORK</phone-type>
<phone-number />
</phone>
<email>johndoe#email.com</email>
<comments>Just any comments here</comments>
</contact-info>
</customer>
</customers>
</new-order>
I try to deserialize it with the following
XmlSerializer ser = new XmlSerializer(typeof(neworder));
neworder feed = (neworder)ser.Deserialize(new FileStream(filePath, FileMode.Open)) ;
The error that I get is the infamous:
There is an error in XML document (1, 2).
http://www.foo.com/schema/w/v1.0'> was not expected.
I've read over and over again about making sure the root note as attribute XMLROOT which the above does. And it has the right namespace.
I've tried changing XmlRootAttribute to XmlRoot. Nothing.
I've tried removing the namespace and re-doing the class and nothing.
Wrecking my brain on what could be wrong here because everything seems legit.

Try this.... (for the XML that you have posted)
Using.....
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Serialization;
Classes.....
[XmlRoot(ElementName = "client-info", Namespace = "http://www.foo.com/schema/w/v1.0")]
public class Clientinfo
{
[XmlElement(ElementName = "client-name", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string Clientname { get; set; }
[XmlElement(ElementName = "w-id", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string Wid { get; set; }
}
[XmlRoot(ElementName = "transferee-name", Namespace = "http://www.foo.com/schema/w/v1.0")]
public class Transfereename
{
[XmlElement(ElementName = "first", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string First { get; set; }
[XmlElement(ElementName = "last", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string Last { get; set; }
}
[XmlRoot(ElementName = "spouse-name", Namespace = "http://www.foo.com/schema/w/v1.0")]
public class Spousename
{
[XmlElement(ElementName = "first", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string First { get; set; }
[XmlElement(ElementName = "last", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string Last { get; set; }
}
[XmlRoot(ElementName = "o-address", Namespace = "http://www.foo.com/schema/w/v1.0")]
public class Oaddress
{
[XmlElement(ElementName = "street1", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string Street1 { get; set; }
[XmlElement(ElementName = "city", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string City { get; set; }
[XmlElement(ElementName = "state", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string State { get; set; }
[XmlElement(ElementName = "postal-code", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string Postalcode { get; set; }
[XmlElement(ElementName = "country", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string Country { get; set; }
}
[XmlRoot(ElementName = "d-address", Namespace = "http://www.foo.com/schema/w/v1.0")]
public class Daddress
{
[XmlElement(ElementName = "street1", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string Street1 { get; set; }
[XmlElement(ElementName = "city", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string City { get; set; }
[XmlElement(ElementName = "state", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string State { get; set; }
[XmlElement(ElementName = "postal-code", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string Postalcode { get; set; }
[XmlElement(ElementName = "country", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string Country { get; set; }
}
[XmlRoot(ElementName = "phone", Namespace = "http://www.foo.com/schema/w/v1.0")]
public class Phone
{
[XmlElement(ElementName = "phone-type", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string Phonetype { get; set; }
[XmlElement(ElementName = "phone-number", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string Phonenumber { get; set; }
}
[XmlRoot(ElementName = "contact-info", Namespace = "http://www.foo.com/schema/w/v1.0")]
public class Contactinfo
{
[XmlElement(ElementName = "phone", Namespace = "http://www.foo.com/schema/w/v1.0")]
public List<Phone> Phone { get; set; }
[XmlElement(ElementName = "email", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string Email { get; set; }
[XmlElement(ElementName = "comments", Namespace = "http://www.foo.com/schema/w/v1.0")]
public string Comments { get; set; }
}
[XmlRoot(ElementName = "customer", Namespace = "http://www.foo.com/schema/w/v1.0")]
public class Customer
{
[XmlElement(ElementName = "client-info", Namespace = "http://www.foo.com/schema/w/v1.0")]
public Clientinfo Clientinfo { get; set; }
[XmlElement(ElementName = "transferee-name", Namespace = "http://www.foo.com/schema/w/v1.0")]
public Transfereename Transfereename { get; set; }
[XmlElement(ElementName = "spouse-name", Namespace = "http://www.foo.com/schema/w/v1.0")]
public Spousename Spousename { get; set; }
[XmlElement(ElementName = "o-address", Namespace = "http://www.foo.com/schema/w/v1.0")]
public Oaddress Oaddress { get; set; }
[XmlElement(ElementName = "d-address", Namespace = "http://www.foo.com/schema/w/v1.0")]
public Daddress Daddress { get; set; }
[XmlElement(ElementName = "contact-info", Namespace = "http://www.foo.com/schema/w/v1.0")]
public Contactinfo Contactinfo { get; set; }
[XmlAttribute(AttributeName = "w-number")]
public string Wnumber { get; set; }
[XmlAttribute(AttributeName = "customer-number")]
public string Customernumber { get; set; }
}
[XmlRoot(ElementName = "customers", Namespace = "http://www.foo.com/schema/w/v1.0")]
public class Customers
{
[XmlElement(ElementName = "customer", Namespace = "http://www.foo.com/schema/w/v1.0")]
public Customer Customer { get; set; }
}
[XmlRoot(ElementName = "new-order", Namespace = "http://www.foo.com/schema/w/v1.0")]
public class Neworder
{
[XmlElement(ElementName = "customers", Namespace = "http://www.foo.com/schema/w/v1.0")]
public Customers Customers { get; set; }
[XmlAttribute(AttributeName = "xsi", Namespace = "http://www.w3.org/2000/xmlns/")]
public string Xsi { get; set; }
[XmlAttribute(AttributeName = "xmlns")]
public string Xmlns { get; set; }
[XmlAttribute(AttributeName = "version")]
public string Version { get; set; }
[XmlAttribute(AttributeName = "supplier-code")]
public string Suppliercode { get; set; }
[XmlAttribute(AttributeName = "schemaLocation")]
public string SchemaLocation { get; set; }
}
Code.....
string strXML = File.ReadAllText("xml.xml");
byte[] bufXML = ASCIIEncoding.UTF8.GetBytes(strXML);
MemoryStream ms1 = new MemoryStream(bufXML);
// Deserialize to object
XmlSerializer serializer = new XmlSerializer(typeof(Neworder));
try
{
using (XmlReader reader = new XmlTextReader(ms1))
{
Neworder deserializedXML = (Neworder)serializer.Deserialize(reader);
}// put a break point here and mouse-over deserializedXML….
}
catch (Exception ex)
{
throw;
}
I am reading your XML in to a string from a file in the application build folder called xml.xml... you will need to get the XML string from somewhere else or create the xml.xml file and save your XML for the code above to work