xmlDeserializer | fill struct filed from XML

Your basic problem is that you have an abstract base class Entity whose inheritors sometimes implement IXmlSerializable and sometimes don't, and when they do they are included in a collection that also implements IXmlSerializable and mingles collection properties with collection children within its XML. Somewhere in the process of reading this XML in you don't advance your XmlReader correctly and deserialization fails.

When implementing IXmlSerializable you need to adhere to the rules stated in this answer to Proper way to implement IXmlSerializable? by Marc Gravell as well as the documentation:

For IXmlSerializable.WriteXml(XmlWriter):

The WriteXml implementation you provide should write out the XML representation of the object. The framework writes a wrapper element and positions the XML writer after its start. Your implementation may write its contents, including child elements. The framework then closes the wrapper element.

For IXmlSerializable.ReadXml(XmlReader):

The ReadXml method must reconstitute your object using the information that was written by the WriteXml method.

When this method is called, the reader is positioned on the start tag that wraps the information for your type. That is, directly on the start tag that indicates the beginning of a serialized object. When this method returns, it must have read the entire element from beginning to end, including all of its contents. Unlike the WriteXml method, the framework does not handle the wrapper element automatically. Your implementation must do so. Failing to observe these positioning rules may cause code to generate unexpected runtime exceptions or corrupt data.

Notice specifically that ReadXml() must entirely consume the container element. This turns out to be problematic in inheritance scenarios; is the base class responsible for consuming the outer element or the derived class? Furthermore, if some derived class improperly positions the XmlReader during reading, this may pass unnoticed by unit tests but cause subsequent data in the XML file to be ignored or corrupted in production.

Thus it makes sense to create an extension framework for reading and writing IXmlSerializable objects whose base and derived classes all have custom (de)serialization logic, in which the processing of the container element, each attribute, and each child element is separated:

The following code works. I changed the namespaces :

I think the error is being thrown because I'm not serializing my model objects into JSON before sending the RestRequest.

restRequest.AddJsonBody(request); will serialize the object and add the appropriate header to the request. The stack trace looks like the issue is with the response being returned as XML and what happens when it tries to desrialize it.

When I run this code, I do note that an HTTP 404 is thrown in the content section of the stack trace.

I think this means that I have an incorrect baseURl but am not sure and would like to know if this is the case or if my code has other issues?

Taking a quick look at their docs it looks like you are calling their (SOAP) XML API. So you are calling the wrong base URL, if the intention is to interact with ProPay REST Interface.

For REST they show the following

Resource URI and HTTP Methods

The request URI is constructed from a Base URI and a Resource URI appended. A Resource URI may be used differently based on the HTTP verb of the request. Consider the following Example:

items is a collection. Change your class to:

Your class structure doesn't fully conform with the XML, it should be something like this:

Assign UIPathOptionsManager.Instance.UIPathOptions to ItemSource. Performed this in Window_Loaded Event.

Formats like xml simply aren't conducive to append, and no standard xml serializers supports what you want to do.

To avoid risk of data loss, you can perhaps load the existing data, add the new object, serialize to a different file, then swap (rename) the files.

There are other formats that are more append-friendly. For example, protobuf doesn't terminate the root element, so if you have a message of the form:

The CDATA is essentially just escaping syntax and is handled by most readers. What you are looking for is:

This is not how XmlSerializer works. The class structure must correspond to structure of the XML in order to work automatically.

This: