We're using Json.NET 8.0.2 in a C# 4.5 project, and we love it.

However this behavior bit us pretty hard:

var obj = JsonConvert.DeserializeObject<JObject>("{ 'x': '2016-03-31T07:02:00+07:00' }");

Here, in our time zone, ob["x"].Value<string>() returns "2016-03-31T02:02:00+02:00".

The problem disappears if we specify how to parse dates:

var obj = JsonConvert.DeserializeObject<JObject>("{ 'x': '2016-03-31T07:02:00+07:00' }",
    new JsonSerializerSettings() { DateParseHandling = DateParseHandling.None });

But I find it dangerously surprising that by default Json.NET interprets strings as dates (let alone the performance issues this inevitably brings with it).

Is this the expected behavior? If so, is there a way to disable this behavior globally?

We all love the lib, but we all don't like having a browser open every time we do a package install. It's borderline obnoxious. Thank you.

JSON.NET currently has PCL folder that targets portable-net45+wp80+win8+wpa81+dnxcore50 this works for older PCL projects and .NET Framework based projects because msbuild adds all of the facades to the compiler target. Moving forward, that's no longer the case. Instead packages are expected to specify what dependencies they use in the nuspec.

Here' an example of System.Collections.nuspec:

<?xml version="1.0"?>
<package xmlns="http://schemas.microsoft.com/packaging/2013/01/nuspec.xsd">
  <metadata minClientVersion="3.0">
    <id>System.Collections</id>
    <version>4.0.10-beta-23110</version>
    <title>System.Collections</title>
    <authors>Microsoft</authors>
    <owners>microsoft,dotnetframework</owners>
    <licenseUrl>http://go.microsoft.com/fwlink/?LinkId=329770</licenseUrl>
    <iconUrl>http://go.microsoft.com/fwlink/?LinkID=288859</iconUrl>
    <requireLicenseAcceptance>true</requireLicenseAcceptance>
    <description>Provides classes that define generic collections, which allow developers to create strongly typed collections that provide better type safety and performance than non-generic strongly typed collections.

Commonly Used Types:
System.Collections.Generic.List&lt;T&gt;
System.Collections.Generic.Dictionary&lt;TKey, TValue&gt;
System.Collections.Generic.Queue&lt;T&gt;
System.Collections.Generic.Stack&lt;T&gt;
System.Collections.Generic.HashSet&lt;T&gt;
System.Collections.Generic.LinkedList&lt;T&gt;
System.Collections.Generic.EqualityComparer&lt;T&gt;
System.Collections.Generic.Comparer&lt;T&gt;
System.Collections.Generic.SortedDictionary&lt;TKey, TValue&gt;</description>
    <copyright>© Microsoft Corporation.  All rights reserved.</copyright>
    <dependencies>
      <group targetFramework="MonoAndroid1.0" />
      <group targetFramework="MonoTouch1.0" />
      <group targetFramework=".NETFramework4.6" />
      <group targetFramework="Xamarin.iOS1.0" />
      <group targetFramework="Xamarin.Mac2.0" />
      <group targetFramework=".NETPlatform5.0">
        <dependency id="System.Runtime" version="4.0.0" />
      </group>
      <group targetFramework=".NETCore5.0">
        <dependency id="System.Runtime" version="4.0.20-beta-23110" />
        <dependency id="System.Resources.ResourceManager" version="4.0.0-beta-23110" />
        <dependency id="System.Diagnostics.Debug" version="4.0.0" />
        <dependency id="System.Threading" version="4.0.0" />
        <dependency id="System.Runtime.Extensions" version="4.0.0" />
      </group>
      <group targetFramework="DNXCore5.0">
        <dependency id="System.Runtime" version="4.0.20-beta-23110" />
      </group>
    </dependencies>
  </metadata>
</package>

Notice that the dependencies are specified in the TFM specific group. That's what JSON.NET should do for .NET Core based platforms. Here's the recommended solution, remove +dnxcore50 from the PCL folder, make a new folder called dotnet and put the dll in there. Specify the dependencies you use in your nuspec with a dependency group targeting dotnet/aka .NETPlatform5.0

Getter-only properties in C# are readonly, but they should still be deserialized.

I.e. this does not work (but should) (Tested in v6.0.8):

public class MyClass
{
    public string MyProp { get; }
}

...

var r = JsonConvert.DeserializeObject<MyClass>("{\"MyProp\":\"awesome\"}");

Assert.AreEqual("awesome", r.MyProp);

However, changing the class to this makes it all work:

public class MyClass
{
    public string MyProp { get; private set; }
}

These two classes should work the same.

Hi,

When do you expect to support the Json Schema Specification (Version 4)?

Contributes to #650

Extracted from #1119 but only covering the async methods on JsonReader and JsonWriter and implementation for JsonTextReader and JsonTextWriter.

The documentation doesn't say whether this works with public or non-public methods, but it does claim that it works similar to XmlSerializer, which in fact accepts private methods.

I think this would be good to allow not spoiling the public API of the types.

Fixes #2292

The existing implementation contains code specifically to disallow dates before Unix epoch. It can be assumed that some users of the library depend on the converter throwing an exception if such date is serialized or deserialized. To maintain backwards compatibility, a constructor parameter and a property are introduced to explicitly enable the new behavior. A static default setting for allowing pre-epoch dates was also introduced to help library users to switch to the new behavior with minimal changes of the client code.

Rationale

Many implementations of Unix time use signed integer values with negative values representing dates before Unix epoch. Examples of such implementations are some C standard libraries and DateTimeOffset.ToUnixTimeSeconds and DateTimeOffset.FromUnixTimeSeconds methods in .NET basic class library. JavaScript built-in Date.prototype.getTime() method type uses milliseconds instead of seconds but it still handles pre-epoch dates with negative numbers. In fact the only implementation disallowing pre-epoch dates I could find was MySQL. Hence negative timestamps are likely to appear in JSON documents in any problem domain that handles dates before 1970-01-01 (e.g. people birthdays).

how to ignore a Property if the property is a Object and all propertes is ignored

For example Tow Class ClassA and ClassB

class ClassA
    {
        public string Code { get; set; }
        public string Name { get; set; }

        public ClassB B { get; set; } = new ClassB();

    ....
   
    }
    class ClassB
    {
        [DefaultValue("auto")] 
        public string Width { get; set; } = "auto";
        [DefaultValue("auto")]

        public string Height { get; set; } = "auto";
        public bool IsReadOnly { get; set; }
        [DefaultValue("string")]
        public string Type { get; set; }= "string";

....
    }
}

   public  static void Test()
        {
            var a = new ClassA
            {
                Code="B"
            };
           
            var settings = new JsonSerializerSettings
            {
                NullValueHandling = NullValueHandling.Ignore,
                DefaultValueHandling = DefaultValueHandling.Ignore,
                MissingMemberHandling = MissingMemberHandling.Ignore,

                TypeNameHandling = TypeNameHandling.None,

            };

            var jsonStr = JsonConvert.SerializeObject(a,Formatting.Indented, settings);
            Debug.Print(jsonStr);
        }

jsonStr value is

{
  "Code": "B",
  "B": {}
}

how can I ignore Serialize B if B All properties is ignore

{
  "Code": "B",
}

JObject.Merge expect only JObject as parameter but has signature Merge(object)

Source/destination types

// Put the types you are serializing or deserializing here
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using Newtonsoft.Json;

namespace GameSharp
{
    public class Node : Resource
    {   
        private int        _index;
        private Node       _parent;
        private List<Node> _children;

        public int    Index 
        {
            get => _parent == null ? -1 : _index;
            set 
            {
                if (_index != value)
                {
                    Parent?._children[Index]?.OnEnd  ();
                    Parent?._children?.Remove(this);

                    _index = value;

                    Parent?._children?.Insert(Index, this);
                    Parent?._children[_index]?.OnStart();
                }
            }
        }
        public Node   Parent 
        {
            get => _index < 0 || _index >= _parent?.Children.Length ? null : _parent;
            set 
            {
                if (_parent != value)
                {
                    Parent?._children[Index]?.OnEnd  ();
                    Parent?._children?.Remove(this);

                    _parent = value;
                    
                    Parent?._children?.Add   (this);
                    Parent?._children[Index]?.OnStart();
                }
            }
        }
        public Node[] Children
        {
            get => _children.ToArray();
        }

        public      Node  ()
        {
            _index    = -1;
            _parent   = null;
            _children = new();
        }
        public Node Copy  ()
        {
            var settings = new JsonSerializerSettings
            {
                PreserveReferencesHandling = PreserveReferencesHandling.Objects,
                ReferenceLoopHandling      = ReferenceLoopHandling.Serialize
            };
            var copy = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(this), GetType(), settings) as Node;
            copy._parent = null;
            copy. Parent = Parent;
            return copy;
        }
        public void Update()
        {
            OnLoop();
        }
        public void Remove()
        {
            Parent = null;
        }

        protected virtual void OnStart() 
        { 
            foreach (var child in Children)
                child.OnStart();
        }
        protected virtual void OnLoop () 
        {
            foreach (var child in Children)
                child.OnLoop();
        }
        protected virtual void OnEnd  () 
        {
            foreach (var child in Children)
                child.OnEnd();
        }
    }
}

Source/destination JSON

{"$id":"1","Index":-1,"Parent":null,"Children":[]}

Expected behavior

id should be pascal case.

Actual behavior

id doesn't respect the pascal case converter i made.

Steps to reproduce

    public static class Content
    {
        public static string Root { get;      } = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
        public static string Path { get; set; } = System.IO.Path.Join(Root, "res"); 

        static Content()
        {
            JsonConvert.DefaultSettings = () => new JsonSerializerSettings()
            {
                ContractResolver           = new PascalCaseContractResolver(),
                PreserveReferencesHandling = PreserveReferencesHandling.Objects,
                ReferenceLoopHandling      = ReferenceLoopHandling.Serialize
            };
        }

        public static bool Load<T>(string filepath, out T value) where T : IResource
        {
            value = default;
            try
            {
                filepath = System.IO.Path.Join(Path, filepath) + ".res";
                
                value .OnLoad(filepath);
                Logger.Info($"Loaded '{ typeof(T).FullName }' from file '{ filepath }'.");
                return true;
            }
            catch
            {
                Logger.Error($"Could not load '{ typeof(T).FullName }' at file '{ filepath }'.");
                return false;
            }
        }
        public static bool Save<T>(string filepath, in  T value) where T : IResource
        {
            try
            {
                filepath = System.IO.Path.Join(Path, filepath) + ".res";

                var path = System.IO.Path.GetDirectoryName(filepath);
                if (!Directory.Exists(path))
                     Directory.CreateDirectory(path);


                value .OnSave(filepath);
                Logger.Info($"Saved '{ typeof(T).FullName }' at file '{ filepath }'.");
                return true;
            }
            catch
            {
                Logger.Error($"Could not load '{ typeof(T).FullName }' at file '{ filepath }'.");
                return false;
            }
        }
        
        private class PascalCaseContractResolver : DefaultContractResolver
        {
            protected override string ResolvePropertyName(string propertyName)
            {
                // Replace all non-letter and non-digits with an underscore and lowercase the rest.
                string sample = string.Join("", propertyName?.Select(c => Char.IsLetterOrDigit(c) ? c.ToString().ToLower() : "_").ToArray());

                // Split the resulting string by underscore
                // Select first character, uppercase it and concatenate with the rest of the string
                var arr = sample?
                    .Split(new []{'_'}, StringSplitOptions.RemoveEmptyEntries)
                    .Select(s => $"{s.Substring(0, 1).ToUpper()}{s.Substring(1)}");

                // Join the resulting collection
                sample = string.Join("", arr);

                return sample;
            }
        }
    }

    public interface     IResource
    {   
        void OnLoad(string filepath);
        void OnSave(string filepath);
    }
    public abstract class Resource : IResource
    {
 

        protected virtual void OnLoad(string filepath)
        {
            JsonConvert.PopulateObject(File.ReadAllText(filepath), this);
        }
        protected virtual void OnSave(string filepath)
        {
            File.WriteAllText(filepath, JsonConvert.SerializeObject(this));
        }

        void IResource.OnLoad(string filepath)
        {
            OnLoad(filepath);
        }
        void IResource.OnSave(string filepath)
        {
            OnSave(filepath);
        }
    }

Feature request

It would be nice to have the feature to specify merge strategies for the object within a JSON. For example, if I want to merge

var object1 = JObject.Parse(@"{
    'ReplaceString': 'test',
    'ReplaceBool': true,
    'ReplaceInt': 3,
    'ReplaceObj': 
    {
        'SomeValue': 'testing',
        'SomeValue5': 'testing5'
    },
    'ReplaceArray': ['test']
}");

var object2 = JObject.Parse(@"{
    'ReplaceString': 'testenterprise',
    'ReplaceBool': false,
    'ReplaceInt': 6,
    'ReplaceObj': 
    {
        'IncompatibleObject': true,
        'SomeValue': 'testingreplaced'
    },
    'ReplaceArray': []
}");

If I use the following merge options

object1.Merge(object2, new JsonMergeSettings
{
    MergeArrayHandling = MergeArrayHandling.Replace,
    MergeNullValueHandling = MergeNullValueHandling.Ignore
});

I get

{
  "ReplaceString": "testenterprise",
  "ReplaceBool": false,
  "ReplaceInt": 6,
  "ReplaceObj": {
    "SomeValue": "testingreplaced",
    "SomeValue5": "testing5",
    "IncompatibleObject": true
  },
  "ReplaceArray": []
}

I'm wondering if would be feasible to have a JsonMergeSettings option that gives control over the objects. Something like

object1.Merge(object2, new JsonMergeSettings
{
    MergeObjectHandling = MergeObjectHandling.Replace
});

So following the previous example, I would get:

{
  "ReplaceString": "testenterprise",
  "ReplaceBool": false,
  "ReplaceInt": 6,
  "ReplaceObj": {
    "SomeValue": "testingreplaced",
    "IncompatibleObject": true
  },
  "ReplaceArray": []
}

where ReplaceObj was completely replaced.