While reading on some literature about cloning objects, I came across the phrase
"If your object is out of the box JSON serializable"
Can someone explain this, please?
With some opposite example preferably (a case of a n object which is not out of the box JSON serializable)
Try to serialize an object with TcpClient property using Newtonsoft.Json:
using Newtonsoft.Json;
using System.Net.Sockets;
class A
{
public TcpClient TcpClient { get; set; } = new TcpClient();
}
var a = new A();
JsonConvert.SerializeObject(a);
It will throw following exception:
Error getting value from 'MulticastLoopback' on 'System.Net.Sockets.Socket'.
Accessing MulticastLoopback from TcpClient throws an exception:
var ml = a.TcpClient.Client.MulticastLoopback;
but if we would have UdpClient instead:
class A
{
public UdpClient UdpClient { get; set; } = new UdpClient();
}
var a = new A();
var ml = a.UdpClient.Client.MulticastLoopback; // ok here
JsonConvert.SerializeObject(a); // Exception here
Then accessing that particular property will not fail, but it will fail at
var ls = a.UdpClient.Client.LingerState;
And serialization will throw an exception:
Error getting value from 'LingerState' on 'System.Net.Sockets.Socket'.
UdpClient and TcpClient share common property ".Client" which is of a type System.Net.Sockets.Socket and some members in this class are valid only for TCP connections and some only for UDP connections.
MulticastLoopback cannot be accessed from TCP sockets and LingerState cannot be accessed from UDP sockets, thus TcpClient and UdpClient are not "out of the box JSON serializable".
EDIT: To summarize, serialization for some types of objects doesn't make sense, so they are not designed to be serializable. Socket class is the one.
What can and cannot be serialized depends on the implementation, but let's take a look at the documentation for Json.NET which is the most commonly used JSON serialization library:
At a high level, the Json.NET serializer will convert primitive .NET values into primitive JSON values, will convert .NET arrays and collections to JSON arrays, and will convert everything else to JSON objects.
Json.NET will throw an error if it encounters incorrect JSON when deserializing a value. For example, if the serializer encounters a JSON property with an array of values and the type of matching .NET property is not a collection, then an error will be thrown, and vice-versa.
[...]
By default a type's properties are serialized in opt-out mode. What that means is that all public fields and properties with getters are automatically serialized to JSON, and fields and properties that shouldn't be serialized are opted-out by placing JsonIgnoreAttribute on them. To serialize private members, the JsonPropertyAttribute can be placed on private fields and properties.
[...]
So basically, if the class members are limited to basic .NET types and there are no private members without a matching public member, you should be good to go. If for example you have private int foo without public int Foo { get { return foo; } set { foo = value; } }, data will be lost during serialization (unless you apply JsonPropertyAttribute).
It's worth it to read the full document I linked, so you have a better understanding of how serialization works.
First thing that comes to mind are circular dependencies.
Let's say we have a class that has a field referencing its child, and the child class has a field referencing its parent.
public class A
{
public B Child;
}
public class B
{
public A Parent;
}
public class Program
{
private static void Main()
{
A a = new A();
B b = new B();
a.Child = b;
b.Parent = a;
string json = JsonConvert.SerializeObject(a);
}
}
This would cause a run-time JsonSerializationException at JsonConvert.SerializeObject(a) with the following message:
Self referencing loop detected for property 'Parent' with type 'A'. Path 'Child'.
To avoid this, JSON.NET provides an overload of SerializeObject to pass a settings object, where we can specifiy how to handle circular references.
JsonSerializerSettings settings = new JsonSerializerSettings
{
PreserveReferencesHandling = PreserveReferencesHandling.None,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
};
JsonConvert.SerializeObject(a, settings);
This way, the output json would completely ignore the circular reference from the child to the parent, and it would look like this:
{
"Child": {}
}
JSON.NET also provides a way to handle them without losing information. We'd need to specifiy the option PreserveReferencesHandling.Objects in the settings.
JsonSerializerSettings settings = new JsonSerializerSettings
{
PreserveReferencesHandling = PreserveReferencesHandling.Objects
};
The output JSON can only be interpreted by JSON.NET or other serializers compatible with the $id and $ref syntax, and it will look like this:
{
"$id":"1",
"Child": {
"$id":"2",
"Parent": {
"$ref":"1"
}
}
}
