We Keep Coding

Deserializing XML to C# child class

My XML :
<?xml version="1.0" encoding="UTF-8"?>
<response id="41cc788a-bc22-4ce0-8e1c-83bf49bbffed">
<message>Successfully processed the request</message>
<payload>Alive</payload>
</response>
My Classes :
[XmlRoot("response")]
[Serializable]
public abstract class ESBResponseBase<T>
{
[XmlAttribute]
public string Id { get; set; }
public string Message { get; set; }
public T Payload { get; set; }
}
[XmlRoot("response")]
[Serializable]
public class ESBResponseIsAlive : ESBResponseBase<string>
{
}
Note that if I don't have these classes on the child classes it throws an exception so it seems inheritance doesn't work with these.
My Serialization Code :
XmlSerializer serializer = new XmlSerializer(typeof (ESBResponseIsAlive));
var esbResponseIsAlive = (ESBResponseIsAlive) serializer.Deserialize(result);
However when I serialize my object properties are null.
I think more than likely this is an issue with inheritance in classes used for serializing. It is possible to simply change the base class to the actual concrete class and use the Generic, but I preferred to have it strongly typed.

As it turns out, XMLSerializer is case-sensitive. My class now looks like the following and it works.
[XmlAttribute("id")]
public string Id { get; set; }
[XmlElement("message")]
public string Message { get; set; }
[XmlElement("payload")]
public T Payload { get; set; }

Removing XML namespace from WebApi

I'm working with a WebApi and XML as result.
I just keep receiving a weird namespace in my result, for exemple:
<QueryId>FE04A4E6-A584-47BF-9DA1-7360DFB08A8D</QueryId>
<ExecutionError>true</ExecutionError>
<OperationResult xmlns:d2p1="http://schemas.datacontract.org/2004/07/MyTypes" i:nil="true"/>
<ErrorMessage>INVALID ACCOUNT</ErrorMessage>
I read some solutions and included this at my WebApiConfig.cs:
config.Formatters.XmlFormatter.UseXmlSerializer = true;
But using this parameter, my return was the same without OperationResult tag (the only one that was not filled out):
<QueryId>FE04A4E6-A584-47BF-9DA1-7360DFB08A8D</QueryId>
<ExecutionError>true</ExecutionError>
<ErrorMessage>INVALID ACCOUNT</ErrorMessage>
I was trying to use my result object like this:
[DataContract(Namespace = "")]
public class CustomRecordResult
{
[DataMember]
public string QueryId { get; set; }
[DataMember]
public bool ExecutionError { get; set; }
[DataMember]
public string ErrorMessage { get; set; }
[DataMember]
public CustomSourceRecord OperationResult { get; set; }
}
But it´s not working. My result object is empty in this case
Any ideas?
Thank you very much!

Use the EmitDefaultValue option to control whether that member will be serialized when it is null.
[DataMember(EmitDefaultValue = false)]
public CustomSourceRecord OperationResult { get; set; }

ASP.net Web API: change class name when serializing

I have a Data Transfer Object class for a product
public class ProductDTO
{
public Guid Id { get; set; }
public string Name { get; set; }
// Other properties
}
When the Asp.net serializes the object in JSON (using JSON.NET) or in XML, it generates ProductDTO objects.
However, i want to change the name during serialization, from ProductDTO to Product, using some kind of attributes:
[Name("Product")]
public class ProductDTO
{
[Name("ProductId")]
public Guid Id { get; set; }
public string Name { get; set; }
// Other properties
}
How can i do this?

I can't see why the class name should make it into the JSON-serialized data, but as regards XML you should be able to control the type name via DataContractAttribute, specifically via the Name property:
using System.Runtime.Serialization;
[DataContract(Name = "Product")]
public class ProductDTO
{
[DataMember(Name="ProductId")]
public Guid Id { get; set; }
[DataMember]
public string Name { get; set; }
// Other properties
}
DataContractAttribute is relevant because the default XML serializer with ASP.NET Web API is DataContractSerializer. DataContractSerializer is configured through DataContractAttribute applied to serialized classes and DataMemberAttribute applied to serialized class members.

An option is to use the default .Net Serialization attributes for this:
[DataContract(Name = "Product")]
public class ProductDTO
{
[DataMember(Name = "ProductId")]
public Guid Id { get; set; }
[DataMember]
public string Name { get; set; }
// Other properties
}

XML Deserialization with Servicestack.Text

I am learning Servicestack.Text Library as it has some of the best features.I am trying to deserialize XML into one of my DTOs as below;
C# Code:[Relevant Code with Console Application Here]
class Program
{
static void Main(string[] args)
{
string str = "http://static.cricinfo.com/rss/livescores.xml";
WebClient w = new WebClient();
string xml = w.DownloadString(str);
Response rss = xml.FromXml<Response>();
foreach (var item in rss.rss.Channel.item)
{
Console.WriteLine(item.title);
}
Console.Read();
}
}
You can go through the XML file at str[Given in the program]. I have prepared DTOs for the deserialization. They are as below:
public class Response
{
public RSS rss { get; set; }
}
public class RSS
{
public string Version { get; set; }
public ChannelClass Channel { get; set; }
}
public class ChannelClass
{
public string title { get; set; }
public string ttl { get; set; }
public string description { get; set; }
public string link { get; set; }
public string copyright { get; set; }
public string language { get; set; }
public string pubDate { get; set; }
public List<ItemClass> item { get; set; }
}
public class ItemClass
{
public string title { get; set; }
public string link { get; set; }
public string description { get; set; }
public string guid { get; set; }
}
When I run the program, I get an exception as shown below:
So, to change the Element and the namespace, I did following workaround:
I put the DataContractAttribute on my Response class as below:
[DataContract(Namespace = "")]
public class Response
{
public RSS rss { get; set; }
}
I changed the Element name as below by adding following two lines just before deserializing
//To change rss Element to Response as in Exception
xml = xml.Replace("<rss version=\"2.0\">","<Response>");
//For closing tag
xml = xml.Replace("</rss>","</Response>");
But, it gave another exception on the foreach loop as the deserialized rss object was null. So, how should I deserialize it in a proper way using Servicestack.Text?
Note :
I know well how to deserialize with other libraries, I want to do it with ServiceStack only.

TLDR: Use XmlSerializer to deserialize from xml dialects you can't control; ServiceStack is designed for code-first development and can not be adapted to general purpose xml parsing.
ServiceStack.Text does not implement a custom Xml serializer - it uses DataContractSerializer under the hood. FromXml is merely syntactic sugar.
Using DataContractSerializer to parse Xml
As you've noticed, DataContractSerializer is picky about namespaces. One approach is to specify the namespace explicitly on the class, but if you do this, you'll need to specify [DataMember] everywhere since it assumes that if anything is explicit, everything is. You can work around this problem using an assembly-level attribute (e.g. in AssemblyInfo.cs) to declare a default namespace:
[assembly: ContractNamespace("", ClrNamespace = "My.Namespace.Here")]
This solves the namespace issue.
However, you cannot solve 2 other issues with DataContractSerializer:
It will not use attributes (in your case, version)
It requires that collections such as item have both a wrapping name and an element name (something like items and item)
You cannot work around these limitations because DataContractSerializer is not a general-purpose XML parser. It is intended to easily produce and consume an API, not map arbitrary XML onto a .NET datastructure. You will never get it to parse rss; so therefore ServiceStack.Text (which just wraps it) can also not parse it.
Instead, use XmlSerializer.
Using XmlSerializer
This is rather straighforward. You can parse input with something along the lines of:
var serializer = new XmlSerializer(typeof(RSS));
RSS rss = (RSS)serializer.Deserialize(myXmlReaderHere);
The trick is to annotate the various fields such that they match your xml dialect. For example, in your case that would be:
[XmlRoot("rss")]
public class RSS
{
[XmlAttribute]
public string version { get; set; }
public ChannelClass channel { get; set; }
}
public class ChannelClass
{
public string title { get; set; }
public string ttl { get; set; }
public string description { get; set; }
public string link { get; set; }
public string copyright { get; set; }
public string language { get; set; }
public string pubDate { get; set; }
[XmlElement]
public List<ItemClass> item { get; set; }
}
public class ItemClass
{
public string title { get; set; }
public string link { get; set; }
public string description { get; set; }
public string guid { get; set; }
}
So some judicious attributes suffice to get it to parse the XML as you want.
In summary: you cannot use ServiceStack for this since it uses DataContractSerializer.ServiceStack/DataContractSerializer are designed for scenarios where you control the schema. Use XmlSerializer instead.

A few things:
Since you are using the [DataContract] attribute. You must include the DTOs properties with the [DataMember] Attribute or they will be skipped in the serialization/deserialization process. Use the assembly attribute as specified in XML deserializing only works with namespace in xml
Your xml manipulation needs to change to wrap the rss inside a response instead or replacing it.
xml = xml.Replace("<rss version=\"2.0\">", "<Response><rss version=\"2.0\">");
I would recommend building an test Response object yourself, serlialize it to XML using ServiceStack's .ToXml() method to see the format it is expecting. You will see service stack handles the channel items as a child list of items that is not how the RSS formats the channel items. You would have to wrap all your items into a node called <ItemClass>

Deserializing JSON from ASP.net web service into C# object

After spending a day reading through posts here I still can't get this to work so hopefully this makes sense to someone here.
The web service returns this simple JSON
{"d":{"__type":"TestWebServices.Person","Name":"Bob","FavoriteColor":"Green","ID":0}}
Then I am using C# code to deserialize
DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(Person));
Person someone = (Person)jsonSerializer.ReadObject(responseStream);
When I use this model someone is created but all the properties are null
[DataContract]
public class Person {
[DataMember]
public string Name { get; set; }
[DataMember]
public string FavoriteColor { get; set; }
[DataMember]
public int ID { get; set; }
}
I tried being more literal and used this model
[DataContract]
public class Person {
[DataMember]
public PersonItem d { get; set; }
}
[DataContract]
public class PersonItem {
[DataMember]
public string __Type { get; set; }
[DataMember]
public string Name { get; set; }
[DataMember]
public string FavoriteColor { get; set; }
[DataMember]
public int ID { get; set; }
}
And got this error, which I don't even know where to start with
Element ':d' contains data from a type that maps to the name ':GEMiniWebServices.Person'. The deserializer has no knowledge of any type that maps to this name. Consider using a DataContractResolver or add the type corresponding to 'TestWebServices.Person' to the list of known types - for example, by using the KnownTypeAttribute attribute or by adding it to the list of known types passed to DataContractSerializer.
Any thoughts?
Thanks

__Type should never be part of your object. It's a hint to the serializer. Also, the type hint that you have in your JSON object is bad. Stand-Alone JSON Serialization says:
To preserve type identity, when serializing complex types to JSON a
"type hint" can be added, and the deserializer recognizes the hint and
acts appropriately. The "type hint" is a JSON key/value pair with the
key name of "__type" (two underscores followed by the word "type").
The value is a JSON string of the form
"DataContractName:DataContractNamespace" (anything up to the first
colon is the name).
The type hint is very similar to the xsi:type attribute defined by the
XML Schema Instance standard and used when serializing/deserializing
XML.
Data members called "__type" are forbidden due to potential conflict
with the type hint.
It works with the following if you rewrite the __type declaration as Person:#TestWebServices or eliminate it:
namespace TestWebServices
{
[KnownType(typeof(Person))]
[DataContract]
public class PersonWrapper
{
[DataMember]
public Person d { get; set; }
}
[DataContract]
public class Person
{
[DataMember]
public string Name { get; set; }
[DataMember]
public string FavoriteColor { get; set; }
[DataMember]
public int ID { get; set; }
}
}

Try adding (and I'm kind of taking a bit of a stab here so the exact namespace my be incorrect)
[DataContract(Namespace = "http://schemas.datacontract.org/2004/07/TestWebServices.Person")]
to your DataContractAttribute on Person.
[DataContract(Namespace = "http://schemas.datacontract.org/2004/07/TestWebServices.Person")]
public class Person {
[DataMember]
public PersonItem d { get; set; }
}
[DataContract]
public class PersonItem {
[DataMember]
public string __Type { get; set; }
[DataMember]
public string Name { get; set; }
[DataMember]
public string FavoriteColor { get; set; }
[DataMember]
public int ID { get; set; }
}