JSON.Net serializer ignoring JsonProperty?

Question

I have the following entity class:

public class FacebookComment : BaseEntity
{
    [BsonId(IdGenerator = typeof(ObjectIdGenerator))]
    [BsonRepresentation(MongoDB.Bson.BsonType.ObjectId)]
    [JsonProperty("_id")]
    public ObjectId Id { get; set; }

    public int? OriginalId { get; set; }
    public DateTime Date { get; set; }
    public string Message { get; set; }
    public string Sentiment { get; set; }
    public string Author { get; set; }
}

When this object is serialized to JSON, I want the Id field to be written as "_id":{...}. AFAIK, I should just have to pass the desired propertyname to the JsonProperty attribute; and I should be good to go. However, when I call JsonConvert.SerializeObject; it seems to ignore my attribute and renders this instead:

{
    Author: "Author name",
    Date: "/Date(1321419600000-0500)/",
    DateCreated: "/Date(1323294923176-0500)/",
    Id: {
        CreationTime: "/Date(0)/",
        Increment: 0,
        Machine: 0,
        Pid: 0,
        Timestamp: 0
    },
    Message: "i like stuff",
    OriginalId: null,
    Sentiment: "Positive"
}

As you can see, the Id field is being rendered with the wrong field name.

Any ideas? Been working on this issue for an hour; can't figure out why the serializer is seemingly ignoring my JsonProperty.

Any constructive input is greatly appreciated.

Answer 1

Short Answer: Make sure all your assemblies are referencing the SAME EXACT JSON.NET DLL. What's probably happening is you are applying [JsonProperty] from one DLL in one assembly, and serializing the object from a different assembly which is looking for a different [JsonProperty] and because the CLR object types are different it is effectively being ignored.

---

Longer Answer: I just had this problem but fortunately because I had one class that was working with JsonProperty and one that wasn't I was able to do some detective work.

I stripped the non-working class down to the bare minimum and compared it to the working class and couldn't see ANY differences - except for the fact that the non-working class was in a different assembly.

When I moved the class to the other assembly it worked perfectly as it should.

I poked around for a bit trying to look into JSON serialization of namespaces, but that didn't seem to apply so I looked at the references and sure enough I was referencing an old JSONNET3.5 DLL in my entities DLL and the NUGET 4.5 version in my main project file.

This gives me two instances of [JsonProperty] attribute (which is just a regular class) and just because they're named the same doesn't mean the serializer is going to even recognise the attribute.

Answer 2

I had the same problem (.Net Core 3.1) and the reason was that I was using JsonPropertyName annotation, which is in System.Text.Json.dll but using JsonConvert.Serialize(string), which is obviously in Newtonsoft.Json.dll. It seems the serialization functions only respect their own library annotations. Changing JsonPropertyName annoation to JsonProperty fixed it, as the latter is in Newtonsoft.Json.dll

Answer 3

In my case I was applying the JsonProperty atrtibute on properties alright, but since I was using asp.net core 3.1, types from System.Text.Json were used, not types from JSON.Net. So if you start using asp.core 3.1, you should make a decision as to which library you would like to use for json. HTH.

Answer 4

This post helped me.

I used serialiser:

new JavaScriptSerializer().Serialize(message)

But rigtly use this:

JsonConvert.SerializeObject(message);

Answer 5

I fixed this issue by marking my Id property with [System.Runtime.Serialization.DataMember(Name="_id")] instead of JsonProperty. Still not entirely clear as to why it didn't work originally though...

Answer 6

In my case, I was using record types, which means you have to use a property: prefix for the fields as mentioned in this question:

public record Person
(
  [property:JsonPropertyName("name")]
  string Name,
);

Answer 7

I also found that my JsonProperty tags were being ignored. I ultimately found that a silent failure loading Newtonsoft Json was to blame. Nancy.Serialization.JsonNet tries to load Newtonsoft Json 9.0.0.0 which was an earlier version than I had installed. No error is surfaced and the serializer provided by Nancy.Serialization.JsonNet is unavailable. Adding a library mapping to the application config fixed the issue:

<configuration>
    <runtime>
        <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
            <dependentAssembly>
                <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
                <bindingRedirect oldVersion="0.0.0.0-12.0.0.0" newVersion="12.0.0.0" />
            </dependentAssembly>
        </assemblyBinding>
    </runtime>
</configuration>

This was discovered by trying to load the JsonNetSerializer early within the Main method:

Type t=typeof(JsonNetSerializer);

This triggered the load error and lead to the config resolution.