When passing objects across RPC call’s its a good practice to declare concrete parameter types in the RPC interface. If for some reason you cannot use concrete class in the RPC interface try to be as specific as possible. This is because the GWT compiler while emitting javascript has to take into account all possible … Read more
You need to show bit more code, specifically on how you invoke deserialization, but from the error I would guess you are not passing parameterization of T. If it is missing, T can only be assumed to be of type Object, and nominal type of Object is bound to “native” Java type, which for JSON … Read more
The earlier answers are good, but they won’t work for non-continuous matrices which arise when you want to serialize regions of interest (among other things). Also, it is unnecessary to serialize elemSize() because this is derived from the type value. Here’s some code that will work regardless of continuity (with includes/namespace) #pragma once #include <boost/archive/text_oarchive.hpp> … Read more
You could use the XMLSerializer: var aSerializer = new XmlSerializer(typeof(A)); StringBuilder sb = new StringBuilder(); StringWriter sw = new StringWriter(sb); aSerializer.Serialize(sw, new A()); // pass an instance of A string xmlResult = sw.GetStringBuilder().ToString(); For this to work properly you will also want xml annotations on your types to make sure it is serialized with the … Read more
If you use the Newtonsoft Json.NET library you can do the following. Define a converter to write the list of key/value pairs the way you want: class MyConverter : JsonConverter { public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { List<KeyValuePair<string, object>> list = value as List<KeyValuePair<string, object>>; writer.WriteStartArray(); foreach (var item in list) … Read more
To do that you need two levels: [XmlRoot(“TestXML”)] public class TestXml { [XmlElement(“TestElement”)] public TestElement TestElement { get; set; } } public class TestElement { [XmlText] public int Value {get;set;} [XmlAttribute] public string attr1 {get;set;} [XmlAttribute] public string attr2 {get;set;} } Note that the > 26 < may cause problems too (whitespace); you may need … Read more
When you register a regular type adapter (GsonBuilder.registerTypeAdapter), it only generates a type adapter for THAT specific class. For example: public abstract class Animal { abstract void speak(); } public class Dog extends Animal { private final String speech = “woof”; public void speak() { System.out.println(speech); } } // in some gson related method gsonBuilder.registerTypeAdapter(Animal.class, … Read more
If I recall correctly(IIRC), if you don’t use formal data-contract markers, it defaults to acting like a field-serializer. This will work, but is less easy to version, since private changes can break the client/server. IMO you should always formally decorate WCF types with the data-contract/data-member attributes. It will work without them, but for the wrong … Read more
Interfaces define a contract and do not have any state of their own. Serialization is about saving and loading state into and out of an object model. Not much point to serializing something that holds no state. To answer the practical question of forcing an implementation of an interface to be Serializable – this is … Read more
There’s a workaround: define a new Dummy class with member fields of all the types that you want to be included in serialization. Then add a method to your RPC interface: Dummy dummy(Dummy d); The implementation is just this: Dummy dummy(Dummy d) { return d; } And the async interface will have this: void dummy(Dummy … Read more