Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Why does Json.Net call the Equals method on my objects when serializing?

I just ran into an error when I was using the Newtonsoft.Json SerializeObject method. It has been asked before here, but there was no answer from the people working with Newtonsoft as to why this happens.

Basically, when calling SerializeObject like this:

string json = Newtonsoft.Json.JsonConvert.SerializeObject(from, new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.All });

I get errors in a lot of Equals methods I have overridden in my classes:

public override bool Equals(object obj)
{
    if (obj == null)
        return false;

    CapacityConfiguration cc = (CapacityConfiguration)obj; // <-- TypeCastException here; other Properties of the same class are sent in as parameter!
}

And of course I realize that it's "easy" to fix, by checking like this:

public override bool Equals(object obj)
{
    if (obj is CapacityConfiguration == false)
        return false;

    CapacityConfiguration cc = (CapacityConfiguration)obj;
}

But the real question is: Why does Json.Net send in other types of objects in the Equals method of the class? More specifically, Json.Net seems to send in a lot of other properties in the class, instead of another object of the same type.

To me, it's completely weird. Any input would be appreciated.

I am using "Version 8.0.0.0" according to Visual Studio.

UPDATE 1

It's easy to test, as it is reproducible:

public class JsonTestClass
{
    public string Name { get; set; }
    public List<int> MyIntList { get; set; }

    public override bool Equals(object obj)
    {
        if (obj == null)
            return false;

        JsonTestClass jtc = (JsonTestClass)obj;
        return true;
    }
}

And then just place this code in Program.cs or anywhere else:

JsonTestClass c = new JsonTestClass();
c.Name = "test";
c.MyIntList = new List<int>();
c.MyIntList.Add(1);

string json = Newtonsoft.Json.JsonConvert.SerializeObject(c, new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.All });

and you will get the TypeCast Exception:

enter image description here

like image 798
Ted Avatar asked Aug 03 '18 09:08

Ted


People also ask

What is JSON serialization exception?

JsonSerializationException(String, String, Int32, Int32, Exception) Initializes a new instance of the JsonSerializationException class with a specified error message, JSON path, line number, line position, and a reference to the inner exception that is the cause of this exception.

What is serializing and deserializing JSON?

JSON is a format that encodes objects in a string. Serialization means to convert an object into that string, and deserialization is its inverse operation (convert string -> object).

What is JSON serialization in C#?

Serialization is the process of converting . NET objects such as strings into a JSON format and deserialization is the process of converting JSON data into . NET objects. In this article and code examples, first we will learn how to serialize JSON in C# and then we will learn how to deserialize JSON in C#.


1 Answers

Why will JsonConvert.SerializeObject call the object.Equals method?

Because when you use JsonConvert.SerializeObject, there is a method CheckForCircularReference which is called to check whether a property re-references your own object, leading to an infinite loop.

 private bool CheckForCircularReference(JsonWriter writer, object value, JsonProperty property, JsonContract contract, JsonContainerContract containerContract, JsonProperty containerProperty)

In the CheckForCircularReference method, part of code uses the Contains method, which will call object.Equals if your object didn't implement the IEquatable<T> interface.

bool exists = (Serializer._equalityComparer != null)
                ? _serializeStack.Contains(value, Serializer._equalityComparer)
                : _serializeStack.Contains(value);

Explanation

  1. _serializeStack is a list of objects currently being serialized.
  2. The List<T>.Contains method checks whether the current property is or isn't contained in the collection.
  3. List<T>.Contains uses EqualityComparer<T>.Default, which in turn uses IEquatable<T> if the type implements it, or object.Equals otherwise.
  4. The object value parameter is your current Property object.

Here is an example of a self-referencing loop:

public class JsonTestClass
{
    public string Name { get; set; }
    public List<int> MyIntList { get; set; }
    public JsonTestClass Test{get;set;}
    public override bool Equals(object obj)
    {
        if (obj == null)
            return false;
        JsonTestClass jtc = (JsonTestClass)obj;
        return true;
   }
}

JsonTestClass c = new JsonTestClass();
c.Name = "test";
c.Test = c;
string json = JsonConvert.SerializeObject
               (c, new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.All });

We will get an exception:

Self referencing loop detected for property 'test' with type 'Program+JsonTestClass'. Path ''.

But if we do it like this there is no error:

JsonTestClass c = new JsonTestClass();
c.Name = "test";
c.Test = new JsonTestClass();

string json = JsonConvert.SerializeObject
       (c, new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.All });
like image 59
D-Shih Avatar answered Oct 22 '22 10:10

D-Shih