diff --git a/.gitignore b/.gitignore
index cd628f1a..646c93b1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,4 +4,7 @@
TestResults/
AppPackages/
*.suo
-*.user
\ No newline at end of file
+*.user
+_ReSharper.*
+*.ReSharper.user
+*.resharper.user
\ No newline at end of file
diff --git a/Doc/ConditionalProperties.aml b/Doc/ConditionalProperties.aml
new file mode 100644
index 00000000..ba904a51
--- /dev/null
+++ b/Doc/ConditionalProperties.aml
@@ -0,0 +1,41 @@
+
+
+
+
+ Json.NET has the ability to conditionally serialize properties by placing a ShouldSerialize method on a class.
+ This funtionality is similar to the
+XmlSerializer ShouldSerialize feature
+http://msdn.microsoft.com/en-us/library/53b8022e.aspx
+_blank
+.
+
+
+ ShouldSerialize
+
+ To conditionally serialize a property add a boolean method with the same name as the property and then prefixed the method name
+ with ShouldSerialize. The result of the method determines whether the property is serialized. If the method returns true then the
+ property will be serialized, if it returns false and the property will be skipped.
+
+
+
+
+
+
+
+ IContractResolver
+
+ ShouldSerialize can also be set using an T:Newtonsoft.Json.Serialization.IContractResolver.
+ Conditionally serializing a property using an IContractResolver is useful if you don't want to place a ShouldSerialize method on a class
+ or you didn't declare the class and are unable to.
+
+
+
+
+
+
+ T:Newtonsoft.Json.JsonSerializer
+ T:Newtonsoft.Json.Serialization.IContractResolver
+ M:Newtonsoft.Json.Serialization.JsonProperty.ShouldSerialize
+
+
+
\ No newline at end of file
diff --git a/Doc/ContractResolver.aml b/Doc/ContractResolver.aml
index cd31ee1d..4589c6d5 100644
--- a/Doc/ContractResolver.aml
+++ b/Doc/ContractResolver.aml
@@ -1,54 +1,71 @@
-
-
-
-
-
- The T:Newtonsoft.Json.Serialization.IContractResolver
- interface provides a way to customize how the
- JsonSerializer serializes and deserializes .NET objects to JSON.
- Implementing the IContractResolver interface and then assigning an
- instance to a JsonSerializer lets you control whether the object is
- serialized as a JSON object or JSON array, what object members should be
- serialized, how they are serialized and what they are called.
-
-
-
- DefaultContractResolver
-
-
- The T:Newtonsoft.Json.Serialization.DefaultContractResolver
- is the default resolver used by the
- serializer. It provides many avenues of extensibility in the form of
- virtual methods that can be overriden.
-
-
-
- CamelCasePropertyNamesContractResolver
-
-
- T:Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver
- inherits from DefaultContractResolver and simply overrides the JSON
- property name to be written in
-camelcase
-http://en.wikipedia.org/wiki/CamelCase
-_blank
-.
-
-
-
-
-
- T:Newtonsoft.Json.Serialization.IContractResolver
- T:Newtonsoft.Json.Serialization.DefaultContractResolver
- T:Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver
-
-
+
+
+
+
+
+ The T:Newtonsoft.Json.Serialization.IContractResolver
+ interface provides a way to customize how the
+ JsonSerializer serializes and deserializes .NET objects to JSON.
+ Implementing the IContractResolver interface and then assigning an
+ instance to a JsonSerializer lets you control whether the object is
+ serialized as a JSON object or JSON array, what object members should be
+ serialized, how they are serialized and what they are called.
+
+
+
+ DefaultContractResolver
+
+
+ The T:Newtonsoft.Json.Serialization.DefaultContractResolver
+ is the default resolver used by the
+ serializer. It provides many avenues of extensibility in the form of
+ virtual methods that can be overriden.
+
+
+
+ CamelCasePropertyNamesContractResolver
+
+
+ T:Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver
+ inherits from DefaultContractResolver and simply overrides the JSON
+ property name to be written in
+camelcase
+http://en.wikipedia.org/wiki/CamelCase
+_blank
+.
+
+
+
+
+
+ Custom Examples
+
+ Setting a T:Newtonsoft.Json.JsonConverter on a type
+ using an IContractResolver.
+
+
+
+
+ Conditionally serializing properties
+ ConditionalProperties.htm
+ _self
+ using an IContractResolver.
+
+
+
+
+
+ T:Newtonsoft.Json.Serialization.IContractResolver
+ T:Newtonsoft.Json.Serialization.DefaultContractResolver
+ T:Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver
+
+
\ No newline at end of file
diff --git a/Doc/JsonNetVsDotNetSerializers.aml b/Doc/JsonNetVsDotNetSerializers.aml
new file mode 100644
index 00000000..b6956e83
--- /dev/null
+++ b/Doc/JsonNetVsDotNetSerializers.aml
@@ -0,0 +1,454 @@
+
+
+
+
+ Json.NET offers many features not found in the JavaScriptSerializer and DataContractSerializer that come with .NET.
+
+
+ Feature Comparison
+
+
+
+
+
+ Json.NET
+ DataContractJsonSerializer
+ JavaScriptSerializer
+
+
+
+ Supports JSON
+
+
+
+
+
+ Supports BSON
+
+
+
+
+
+ Supports JSON Schema
+
+
+
+
+
+ Supports .NET 2.0
+
+
+
+
+
+ Supports .NET 3.5
+
+
+
+
+
+ Supports .NET 4.0
+
+
+
+
+
+ Supports Silverlight
+
+
+
+
+
+ Supports Windows Phone
+
+
+
+
+
+ Supports WinRT
+
+
+
+
+
+ Open Source
+
+
+
+
+
+ MIT License
+
+
+
+
+
+ LINQ to JSON
+
+
+
+
+
+ Thread Safe
+
+
+
+
+
+ XPath-like JSON query syntax
+
+
+
+
+
+ Indented JSON support
+
+
+
+
+
+
+
+ Efficient dictionary serialization
+ http://stackoverflow.com/questions/1207731/how-can-i-deserialize-json-to-a-simple-dictionarystring-string-in-asp-net
+ _blank
+
+
+
+
+
+
+
+
+
+ Nonsensical dictionary serialization
+ http://stackoverflow.com/questions/4559991/any-way-to-make-datacontractjsonserializer-serialize-dictionaries-properly
+ _blank
+
+
+
+
+
+
+
+ Deserializes IList, IEnumerable, ICollection, IDictionary properties
+
+
+
+
+
+ Serializes circular references
+
+
+
+
+
+ Supports serializing objects by reference
+
+
+
+
+
+ Deserializes polymorphic properties and collections
+
+
+
+
+
+ Serializes and deserializes multidimensional arrays
+
+
+
+
+
+ Supports including type names with JSON
+
+
+
+
+
+ Globally customize serialization process
+
+
+
+
+
+ Supports excluding null values when serializing
+
+
+
+
+
+ Supports SerializationBinder
+
+
+
+
+
+ Conditional property serialization
+
+
+
+
+
+ Includes line number information in errors
+
+
+
+
+
+ Converts XML to JSON and JSON to XML
+
+
+
+
+
+ JSON Schema validation
+
+
+
+
+
+ JSON Schema generation from .NET types
+
+
+
+
+
+ Camel case JSON property names
+
+
+
+
+
+ Non-default constructors support
+
+
+
+
+
+ Serialization error handling
+
+
+
+
+
+ Supports populating an existing object
+
+
+
+
+
+ Efficiently serializes byte arrays as base64 text
+
+
+
+
+
+ Handles NaN, Infinity, -Infinity and undefined
+
+
+
+
+
+ Handles JavaScript constructors
+
+
+
+
+
+ Serializes .NET 4.0 dynamic objects
+
+
+
+
+
+ Serializes ISerializable objects
+
+
+
+
+
+ Supports serializing enums to their text name
+
+
+
+
+
+ JSON recursion limit support
+
+
+
+
+
+ Attribute property name customization
+
+
+
+
+
+ Attribute property order customization
+
+
+
+
+
+ Attribute property required customization
+
+
+
+
+
+ Supports ISO8601 dates
+
+
+
+
+
+ Supports JavaScript constructor dates
+
+
+
+
+
+ Supports Microsoft AJAX dates
+
+
+
+
+
+ Unquoted property names support
+
+
+
+
+
+ Raw JSON support
+
+
+
+
+
+ Supports reading and writing comments
+
+
+
+
+
+ Serializes anonymous types
+
+
+
+
+
+ Deserializes anonymous types
+
+
+
+
+
+ Opt-in mode serialization
+
+
+
+
+
+ Opt-out mode serialization
+
+
+
+
+
+ Field (Serializable) mode serialization
+
+
+
+
+
+ Efficiently stream reading and writing JSON
+
+
+
+
+
+ Single or double quote JSON content
+
+
+
+
+
+ Supports overriding a type's serialization
+
+
+
+
+
+ Supports OnDeserialized, OnSerializing, OnSerialized and OnDeserializing attributes
+
+
+
+
+
+ Supports serializing private properties
+
+
+
+
+
+ DataMember attribute support
+
+
+
+
+
+ MetdataType attribute support
+
+
+
+
+
+ DefaultValue attribute support
+
+
+
+
+
+ Serializes DataSets and DataTables
+
+
+
+
+
+ Serailizes Entity Framework
+
+
+
+
+
+ Serializes nHibernate
+
+
+
+
+
+ Case-insensitive property deserialization
+
+
+
+
+
+
+
+
+ Benchmarks
+
+
+
+
+ Json.NET Performance
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Doc/JsonNetVsWindowsDataJson.aml b/Doc/JsonNetVsWindowsDataJson.aml
new file mode 100644
index 00000000..33e0a5ea
--- /dev/null
+++ b/Doc/JsonNetVsWindowsDataJson.aml
@@ -0,0 +1,101 @@
+
+
+
+
+ Windows 8 introduces a new way to work with JSON via the
+Windows.Data.Json
+http://msdn.microsoft.com/en-us/library/windows/apps/xaml/br240639.aspx
+_blank
+ namespace. Similar to LINQ to JSON in Json.NET
+ it defines classes that can be used to parse values, strings, objects, and arrays from
+ JSON text or serialize value types into JSON text.
+ Below is a comparison of Json.NET's LINQ to JSON to Window 8's Windows.Data.Json.
+
+
+ Exclusive Json.NET Features
+
+
+
+
+ Runs on .NET 2, .NET 3, .NET 4, Silverlight and Windows Phone 7
+
+
+
+
+ Supports dynamic programming
+
+
+
+
+ Write indented JSON
+
+
+
+
+ Customize reading and writing JSON with JsonConverters
+
+
+
+
+ Read and write ISO8601 dates
+
+
+
+
+ Better LINQ support
+
+
+
+
+
+
+ Creating JSON
+
+ The big difference between the two libraries when creating JSON is Windows.Data.Json requires
+ string/integer/double values to be explicitly converted to JsonValue objects.
+ Note that there is a weird limitation to creating JSON with Windows.Data.Json: it doesn't
+ allow you to set properties to null or put null values in an array.
+
+
+
+
+
+
+ Querying JSON
+
+ Windows.Data.Json requires a value to be cast to its exact type with the GetObject/GetArray methods
+ before it can be used, making Windows.Data.Json's code verbose compared to LINQ to JSON.
+
+
+
+
+
+
+ Performance
+
+ Json.NET is slightly slower at writing JSON than Windows.Data.Json but considerably faster at parsing JSON.
+
+
+
+ Json.NET and Windows.Data.Json Performance
+
+
+
+
+
+ Converting Between LINQ to JSON and Windows.Data.Json
+
+ Json.NET supports converting between the types of the two libraries.
+ This feature is useful if you are working with another API but you want to use Json.NET inside your own code.
+ Use Overload:Newtonsoft.Json.Linq.JToken.FromObject to convert a Windows.Data.Json
+ value to LINQ to JSON and use Overload:Newtonsoft.Json.Linq.JToken.ToObject to convert LINQ to JSON to Windows.Data.Json.
+
+
+
+
+
+
+ N:Newtonsoft.Json.Linq
+
+
+
\ No newline at end of file
diff --git a/Doc/Performance.aml b/Doc/Performance.aml
index ce89d2ff..0115f609 100644
--- a/Doc/Performance.aml
+++ b/Doc/Performance.aml
@@ -1,84 +1,84 @@
-
-
-
-
- Out of the box Json.NET is faster than DataContractJsonSerializer and JavaScriptSerializer.
- Here are some tips to make it go even faster.
-
-
- Optimize Memory Usage
-
- To keep an application consistantly fast it is important to minimize the
- amount of time the .NET framework spends performing
-garbage collection
-http://msdn.microsoft.com/en-us/library/ms973837.aspx
-_blank
-.
- Allocating too many objects, or allocating very large objects can slow down or even
- halt an application while garbage collection is in progress.
-
- To minimize memory usage and the number of objects allocated Json.NET supports
- serializing and deserializing directly to a stream. Reading or writing JSON a piece at a time instead of having
- the entire JSON string loaded into memory is especially important when working with JSON
- documents greater than 85kb in size to avoid the JSON string ending up in the
-large object heap
-http://msdn.microsoft.com/en-us/magazine/cc534993.aspx
-_blank
-.
-
-
-
-
-
-
-
- JsonConverters
-
- Passing a T:Newtonsoft.Json.JsonConverter to SerializeObject or DeserializeObject provides a simple way to completely
- change how an object is serialized. There is however a small overhead; the CanConvert method is called for every
- type to check whether serialization should be handled by that JsonConverter.
- There are a couple of ways to continue to use JsonConverters without any overhead. The simplest way
- is to specify the JsonConverter using the T:Newtonsoft.Json.JsonConverterAttribute. This attribute tells the serializer
- to always use that converter when serializing and deserializing the type, without the check.
-
-
-
- If the class you want to convert isn't your own and you're unable to use an attribute a JsonConverter can still be used by
- creating your own T:Newtonsoft.Json.Serialization.IContractResolver.
-
-
-
- The IContractResolver in the example above will set all DateTimes to use the JavaScriptDateConverter.
-
-
-
- Manually Serialize
-
- The absolute fastest way to read and write JSON is to use JsonTextReader and JsonTextWriter directly. Using a reader or writer
- directly skips any of the overhead from a serializer such as reflection.
-
-
-
- If performance is important and you don't mind more code to get it then this is your best choice.
-
-
-
- Benchmarks
-
-
-
-
- Json.NET Performance
-
-
-
-
-
- T:Newtonsoft.Json.JsonSerializer
- T:Newtonsoft.Json.JsonConverter
- T:Newtonsoft.Json.JsonConverterAttribute
- T:Newtonsoft.Json.JsonTextWriter
- T:Newtonsoft.Json.JsonTextReader
-
-
+
+
+
+
+ Out of the box Json.NET is faster than DataContractJsonSerializer and JavaScriptSerializer.
+ Here are some tips to make it go even faster.
+
+
+ Optimize Memory Usage
+
+ To keep an application consistantly fast it is important to minimize the
+ amount of time the .NET framework spends performing
+garbage collection
+http://msdn.microsoft.com/en-us/library/ms973837.aspx
+_blank
+.
+ Allocating too many objects, or allocating very large objects can slow down or even
+ halt an application while garbage collection is in progress.
+
+ To minimize memory usage and the number of objects allocated Json.NET supports
+ serializing and deserializing directly to a stream. Reading or writing JSON a piece at a time instead of having
+ the entire JSON string loaded into memory is especially important when working with JSON
+ documents greater than 85kb in size to avoid the JSON string ending up in the
+large object heap
+http://msdn.microsoft.com/en-us/magazine/cc534993.aspx
+_blank
+.
+
+
+
+
+
+
+
+ JsonConverters
+
+ Passing a T:Newtonsoft.Json.JsonConverter to SerializeObject or DeserializeObject provides a simple way to completely
+ change how an object is serialized. There is however a small overhead; the CanConvert method is called for every
+ value to check whether serialization should be handled by that JsonConverter.
+ There are a couple of ways to continue to use JsonConverters without any overhead. The simplest way
+ is to specify the JsonConverter using the T:Newtonsoft.Json.JsonConverterAttribute. This attribute tells the serializer
+ to always use that converter when serializing and deserializing the type, without the check.
+
+
+
+ If the class you want to convert isn't your own and you're unable to use an attribute a JsonConverter can still be used by
+ creating your own T:Newtonsoft.Json.Serialization.IContractResolver.
+
+
+
+ The IContractResolver in the example above will set all DateTimes to use the JavaScriptDateConverter.
+
+
+
+ Manually Serialize
+
+ The absolute fastest way to read and write JSON is to use JsonTextReader/JsonTextWriter directly to manually serialize types.
+ Using a reader or writer directly skips any of the overhead from a serializer such as reflection.
+
+
+
+ If performance is important and you don't mind more code to get it then this is your best choice.
+
+
+
+ Benchmarks
+
+
+
+
+ Json.NET Performance
+
+
+
+
+
+ T:Newtonsoft.Json.JsonSerializer
+ T:Newtonsoft.Json.JsonConverter
+ T:Newtonsoft.Json.JsonConverterAttribute
+ T:Newtonsoft.Json.JsonTextWriter
+ T:Newtonsoft.Json.JsonTextReader
+
+
\ No newline at end of file
diff --git a/Doc/cross.png b/Doc/cross.png
new file mode 100644
index 00000000..1514d51a
Binary files /dev/null and b/Doc/cross.png differ
diff --git a/Doc/doc.content b/Doc/doc.content
index 47ec2e05..5d8acc9f 100644
--- a/Doc/doc.content
+++ b/Doc/doc.content
@@ -9,11 +9,12 @@
-
+
+
@@ -21,8 +22,10 @@
-
+
+
+
\ No newline at end of file
diff --git a/Doc/doc.shfbproj b/Doc/doc.shfbproj
index 581fb1a9..ce7cf2bd 100644
--- a/Doc/doc.shfbproj
+++ b/Doc/doc.shfbproj
@@ -8,7 +8,7 @@
AnyCPU
2.0
{fd19f68e-72c8-4576-9775-b4480b0db686}
- 1.9.3.0
+ 1.9.5.0
Documentation
@@ -32,7 +32,7 @@
Website
- .NET 4.0.30319
+ .NET Framework 4.0
Json.NET - Documentation
vs2005
MemberName
@@ -70,7 +70,7 @@
-
+
@@ -137,6 +137,9 @@
+
+
+
@@ -166,6 +169,18 @@
+
+ tick
+ tick
+
+
+ cross
+ cross
+
+
+ jsonnetwindowsdatajson
+ jsonnetwindowsdatajson
+
performance
performance
diff --git a/Doc/jsonnetwindowsdatajson.png b/Doc/jsonnetwindowsdatajson.png
new file mode 100644
index 00000000..76c7782a
Binary files /dev/null and b/Doc/jsonnetwindowsdatajson.png differ
diff --git a/Doc/tick.png b/Doc/tick.png
new file mode 100644
index 00000000..a9925a06
Binary files /dev/null and b/Doc/tick.png differ
diff --git a/Src/Newtonsoft.Json.Tests/Documentation/ConditionalPropertiesTests.cs b/Src/Newtonsoft.Json.Tests/Documentation/ConditionalPropertiesTests.cs
new file mode 100644
index 00000000..7ae89735
--- /dev/null
+++ b/Src/Newtonsoft.Json.Tests/Documentation/ConditionalPropertiesTests.cs
@@ -0,0 +1,177 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+#if !(NET35 || NET20 || PORTABLE)
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Dynamic;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Reflection;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading.Tasks;
+using Newtonsoft.Json.Converters;
+using Newtonsoft.Json.Linq;
+#if !NETFX_CORE
+using NUnit.Framework;
+#else
+using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
+using TestFixture = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;
+using Test = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute;
+#endif
+using Newtonsoft.Json.Serialization;
+using Newtonsoft.Json.Tests.TestObjects;
+using Newtonsoft.Json.Utilities;
+using System.Globalization;
+
+namespace Newtonsoft.Json.Tests.Documentation
+{
+ public class Employee
+ {
+ public string Name { get; set; }
+ public Employee Manager { get; set; }
+ }
+
+ #region ShouldSerializeContractResolver
+ public class ShouldSerializeContractResolver : DefaultContractResolver
+ {
+ public new static readonly ShouldSerializeContractResolver Instance = new ShouldSerializeContractResolver();
+
+ protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
+ {
+ JsonProperty property = base.CreateProperty(member, memberSerialization);
+
+ if (property.DeclaringType == typeof(Employee) && property.PropertyName == "Manager")
+ {
+ property.ShouldSerialize =
+ instance =>
+ {
+ Employee e = (Employee) instance;
+ return e.Manager != e;
+ };
+ }
+
+ return property;
+ }
+ }
+ #endregion
+
+ [TestFixture]
+ public class ConditionalPropertiesTests : TestFixtureBase
+ {
+ #region EmployeeShouldSerializeExample
+ public class Employee
+ {
+ public string Name { get; set; }
+ public Employee Manager { get; set; }
+
+ public bool ShouldSerializeManager()
+ {
+ // don't serialize the Manager property if an employee is their own manager
+ return (Manager != this);
+ }
+ }
+ #endregion
+
+ [Test]
+ public void ShouldSerializeClassTest()
+ {
+ #region ShouldSerializeClassTest
+ Employee joe = new Employee();
+ joe.Name = "Joe Employee";
+ Employee mike = new Employee();
+ mike.Name = "Mike Manager";
+
+ joe.Manager = mike;
+
+ // mike is his own manager
+ // ShouldSerialize will skip this property
+ mike.Manager = mike;
+
+ string json = JsonConvert.SerializeObject(new[] { joe, mike }, Formatting.Indented);
+ // [
+ // {
+ // "Name": "Joe Employee",
+ // "Manager": {
+ // "Name": "Mike Manager"
+ // }
+ // },
+ // {
+ // "Name": "Mike Manager"
+ // }
+ // ]
+ #endregion
+
+ Assert.AreEqual(@"[
+ {
+ ""Name"": ""Joe Employee"",
+ ""Manager"": {
+ ""Name"": ""Mike Manager""
+ }
+ },
+ {
+ ""Name"": ""Mike Manager""
+ }
+]", json);
+ }
+
+ [Test]
+ public void ShouldSerializeContractResolverTest()
+ {
+ Newtonsoft.Json.Tests.Documentation.Employee joe = new Newtonsoft.Json.Tests.Documentation.Employee();
+ joe.Name = "Joe Employee";
+ Newtonsoft.Json.Tests.Documentation.Employee mike = new Newtonsoft.Json.Tests.Documentation.Employee();
+ mike.Name = "Mike Manager";
+
+ joe.Manager = mike;
+ mike.Manager = mike;
+
+ string json = JsonConvert.SerializeObject(
+ new[] {joe, mike},
+ Formatting.Indented,
+ new JsonSerializerSettings
+ {
+ ContractResolver = ShouldSerializeContractResolver.Instance
+ });
+
+ Assert.AreEqual(@"[
+ {
+ ""Name"": ""Joe Employee"",
+ ""Manager"": {
+ ""Name"": ""Mike Manager""
+ }
+ },
+ {
+ ""Name"": ""Mike Manager""
+ }
+]", json);
+
+ }
+ }
+}
+#endif
\ No newline at end of file
diff --git a/Src/Newtonsoft.Json.Tests/Documentation/JsonNetVsWindowsDataJsonTests.cs b/Src/Newtonsoft.Json.Tests/Documentation/JsonNetVsWindowsDataJsonTests.cs
new file mode 100644
index 00000000..a8e135a3
--- /dev/null
+++ b/Src/Newtonsoft.Json.Tests/Documentation/JsonNetVsWindowsDataJsonTests.cs
@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Newtonsoft.Json.Linq;
+
+namespace Newtonsoft.Json.Tests.Documentation
+{
+ public class JsonNetVsWindowsDataJsonTests
+ {
+ public void CreatingJson()
+ {
+#if NETFX_CORE
+ #region CreatingJSON
+ // Windows.Data.Json
+ // -----------------
+ JsonObject jsonObject = new JsonObject
+ {
+ {"CPU", JsonValue.CreateStringValue("Intel")},
+ {
+ "Drives", new JsonArray
+ {
+ JsonValue.CreateStringValue("DVD read/writer"),
+ JsonValue.CreateStringValue("500 gigabyte hard drive")
+ }
+ }
+ };
+ string json1 = jsonObject.Stringify();
+
+ // LINQ to JSON
+ // ------------
+ JObject jObject = new JObject
+ {
+ {"CPU", "Intel"},
+ {
+ "Drives", new JArray
+ {
+ "DVD read/writer",
+ "500 gigabyte hard drive"
+ }
+ }
+ };
+ string json2 = jObject.ToString();
+ #endregion
+#endif
+ }
+
+ public void QueryingJson()
+ {
+#if NETFX_CORE
+ #region QueryingJSON
+ string json = @"{
+ 'channel': {
+ 'title': 'James Newton-King',
+ 'link': 'http://james.newtonking.com',
+ 'description': 'James Newton-King's blog.',
+ 'item': [
+ {
+ 'title': 'Json.NET 1.3 + New license + Now on CodePlex',
+ 'description': 'Annoucing the release of Json.NET 1.3, the MIT license and the source being available on CodePlex',
+ 'link': 'http://james.newtonking.com/projects/json-net.aspx',
+ 'category': [
+ 'Json.NET',
+ 'CodePlex'
+ ]
+ }
+ ]
+ }
+ }";
+
+ // Windows.Data.Json
+ // -----------------
+ JsonObject jsonObject = JsonObject.Parse(json);
+ string itemTitle1 = jsonObject["channel"].GetObject()["item"].GetArray()[0].GetObject()["title"].GetString();
+
+ // LINQ to JSON
+ // ------------
+ JObject jObject = JObject.Parse(json);
+ string itemTitle2 = (string)jObject["channel"]["item"][0]["title"];
+ #endregion
+#endif
+ }
+
+ public void Converting()
+ {
+#if NETFX_CORE
+ #region Converting
+ JsonObject jsonObject = new JsonObject
+ {
+ {"CPU", JsonValue.CreateStringValue("Intel")},
+ {"Drives", new JsonArray {
+ JsonValue.CreateStringValue("DVD read/writer"),
+ JsonValue.CreateStringValue("500 gigabyte hard drive")
+ }
+ }
+ };
+
+ // convert Windows.Data.Json to LINQ to JSON
+ JObject o = JObject.FromObject(jsonObject);
+
+ // convert LINQ to JSON to Windows.Data.Json
+ JArray a = (JArray)o["Drives"];
+ JsonArray jsonArray = a.ToObject();
+ #endregion
+#endif
+ }
+ }
+}
\ No newline at end of file
diff --git a/Src/Newtonsoft.Json.Tests/Documentation/PerformanceTests.cs b/Src/Newtonsoft.Json.Tests/Documentation/PerformanceTests.cs
index b0058366..eafc15eb 100644
--- a/Src/Newtonsoft.Json.Tests/Documentation/PerformanceTests.cs
+++ b/Src/Newtonsoft.Json.Tests/Documentation/PerformanceTests.cs
@@ -80,10 +80,13 @@ namespace Newtonsoft.Json.Tests.Documentation
#region JsonConverterContractResolver
public class ConverterContractResolver : DefaultContractResolver
{
+ public new static readonly ConverterContractResolver Instance = new ConverterContractResolver();
+
protected override JsonContract CreateContract(Type objectType)
{
JsonContract contract = base.CreateContract(objectType);
+ // this will only be called once and then cached
if (objectType == typeof(DateTime) || objectType == typeof(DateTimeOffset))
contract.Converter = new JavaScriptDateTimeConverter();
@@ -117,7 +120,7 @@ namespace Newtonsoft.Json.Tests.Documentation
{
string json = JsonConvert.SerializeObject(new DateTime(2000, 10, 10, 10, 10, 10, DateTimeKind.Utc), new JsonSerializerSettings
{
- ContractResolver = new ConverterContractResolver()
+ ContractResolver = ConverterContractResolver.Instance
});
Console.WriteLine(json);
diff --git a/Src/Newtonsoft.Json.Tests/JsonTextWriterTest.cs b/Src/Newtonsoft.Json.Tests/JsonTextWriterTest.cs
index da896424..f6850326 100644
--- a/Src/Newtonsoft.Json.Tests/JsonTextWriterTest.cs
+++ b/Src/Newtonsoft.Json.Tests/JsonTextWriterTest.cs
@@ -713,6 +713,7 @@ _____'propertyName': NaN
jsonWriter.WriteValue(data);
jsonWriter.WriteValue((object)data);
jsonWriter.WriteValue((byte[])null);
+ jsonWriter.WriteValue((Uri)null);
jsonWriter.WriteEndArray();
}
@@ -720,6 +721,7 @@ _____'propertyName': NaN
""SGVsbG8gd29ybGQu"",
""SGVsbG8gd29ybGQu"",
""SGVsbG8gd29ybGQu"",
+ null,
null
]";
string result = sb.ToString();
diff --git a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.csproj b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.csproj
index afa8eb6d..a2083c25 100644
--- a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.csproj
+++ b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.csproj
@@ -117,6 +117,7 @@
+
diff --git a/Src/Newtonsoft.Json.Tests/PerformanceTests.cs b/Src/Newtonsoft.Json.Tests/PerformanceTests.cs
index 7bcc6a18..7b5c016c 100644
--- a/Src/Newtonsoft.Json.Tests/PerformanceTests.cs
+++ b/Src/Newtonsoft.Json.Tests/PerformanceTests.cs
@@ -64,8 +64,8 @@ namespace Newtonsoft.Json.Tests
[TestFixture]
public class PerformanceTests : TestFixtureBase
{
- private const int Iterations = 100;
- //private const int Iterations = 5000;
+ //private const int Iterations = 100;
+ private const int Iterations = 5000;
#region Data
@@ -122,8 +122,6 @@ namespace Newtonsoft.Json.Tests
TestClass test = CreateSerializationObject();
SerializeTests(test);
-
- Deserialize();
}
private void SerializeTests(object value)
diff --git a/Src/Newtonsoft.Json.Tests/Properties/AssemblyInfo.cs b/Src/Newtonsoft.Json.Tests/Properties/AssemblyInfo.cs
index 19683bd3..f5b0c6bd 100644
--- a/Src/Newtonsoft.Json.Tests/Properties/AssemblyInfo.cs
+++ b/Src/Newtonsoft.Json.Tests/Properties/AssemblyInfo.cs
@@ -76,5 +76,5 @@ using System.Security;
// by using the '*' as shown below:
[assembly: AssemblyVersion("4.5.0.0")]
#if !PocketPC
-[assembly: AssemblyFileVersion("4.5.10.15427")]
+[assembly: AssemblyFileVersion("4.5.10.15501")]
#endif
diff --git a/Src/Newtonsoft.Json/JsonTextWriter.cs b/Src/Newtonsoft.Json/JsonTextWriter.cs
index 18f012eb..cb390a98 100644
--- a/Src/Newtonsoft.Json/JsonTextWriter.cs
+++ b/Src/Newtonsoft.Json/JsonTextWriter.cs
@@ -148,7 +148,7 @@ namespace Newtonsoft.Json
///
public override void WriteStartObject()
{
- base.WriteStartObject();
+ InternalWriteStart(JsonToken.StartObject, JsonContainerType.Object);
_writer.Write("{");
}
@@ -158,7 +158,7 @@ namespace Newtonsoft.Json
///
public override void WriteStartArray()
{
- base.WriteStartArray();
+ InternalWriteStart(JsonToken.StartArray, JsonContainerType.Array);
_writer.Write("[");
}
@@ -169,7 +169,7 @@ namespace Newtonsoft.Json
/// The name of the constructor.
public override void WriteStartConstructor(string name)
{
- base.WriteStartConstructor(name);
+ InternalWriteStart(JsonToken.StartConstructor, JsonContainerType.Constructor);
_writer.Write("new ");
_writer.Write(name);
@@ -204,7 +204,7 @@ namespace Newtonsoft.Json
/// The name of the property.
public override void WritePropertyName(string name)
{
- base.WritePropertyName(name);
+ InternalWritePropertyName(name);
JavaScriptUtils.WriteEscapedJavaScriptString(_writer, name, _quoteChar, _quoteName);
@@ -259,7 +259,7 @@ namespace Newtonsoft.Json
///
public override void WriteNull()
{
- base.WriteNull();
+ InternalWriteNull();
WriteValueInternal(JsonConvert.Null, JsonToken.Null);
}
@@ -268,7 +268,7 @@ namespace Newtonsoft.Json
///
public override void WriteUndefined()
{
- base.WriteUndefined();
+ InternalWriteUndefined();
WriteValueInternal(JsonConvert.Undefined, JsonToken.Undefined);
}
@@ -278,7 +278,7 @@ namespace Newtonsoft.Json
/// The raw JSON to write.
public override void WriteRaw(string json)
{
- base.WriteRaw(json);
+ InternalWriteRaw();
_writer.Write(json);
}
@@ -289,7 +289,8 @@ namespace Newtonsoft.Json
/// The value to write.
public override void WriteValue(string value)
{
- base.WriteValue(value);
+ InternalWriteValue(JsonToken.String);
+
if (value == null)
WriteValueInternal(JsonConvert.Null, JsonToken.Null);
else
@@ -302,7 +303,7 @@ namespace Newtonsoft.Json
/// The value to write.
public override void WriteValue(int value)
{
- base.WriteValue(value);
+ InternalWriteValue(JsonToken.Integer);
WriteValueInternal(JsonConvert.ToString(value), JsonToken.Integer);
}
@@ -313,7 +314,7 @@ namespace Newtonsoft.Json
[CLSCompliant(false)]
public override void WriteValue(uint value)
{
- base.WriteValue(value);
+ InternalWriteValue(JsonToken.Integer);
WriteValueInternal(JsonConvert.ToString(value), JsonToken.Integer);
}
@@ -323,7 +324,7 @@ namespace Newtonsoft.Json
/// The value to write.
public override void WriteValue(long value)
{
- base.WriteValue(value);
+ InternalWriteValue(JsonToken.Integer);
WriteValueInternal(JsonConvert.ToString(value), JsonToken.Integer);
}
@@ -334,7 +335,7 @@ namespace Newtonsoft.Json
[CLSCompliant(false)]
public override void WriteValue(ulong value)
{
- base.WriteValue(value);
+ InternalWriteValue(JsonToken.Integer);
WriteValueInternal(JsonConvert.ToString(value), JsonToken.Integer);
}
@@ -344,7 +345,7 @@ namespace Newtonsoft.Json
/// The value to write.
public override void WriteValue(float value)
{
- base.WriteValue(value);
+ InternalWriteValue(JsonToken.Float);
WriteValueInternal(JsonConvert.ToString(value), JsonToken.Float);
}
@@ -354,7 +355,7 @@ namespace Newtonsoft.Json
/// The value to write.
public override void WriteValue(double value)
{
- base.WriteValue(value);
+ InternalWriteValue(JsonToken.Float);
WriteValueInternal(JsonConvert.ToString(value), JsonToken.Float);
}
@@ -364,7 +365,7 @@ namespace Newtonsoft.Json
/// The value to write.
public override void WriteValue(bool value)
{
- base.WriteValue(value);
+ InternalWriteValue(JsonToken.Boolean);
WriteValueInternal(JsonConvert.ToString(value), JsonToken.Boolean);
}
@@ -374,7 +375,7 @@ namespace Newtonsoft.Json
/// The value to write.
public override void WriteValue(short value)
{
- base.WriteValue(value);
+ InternalWriteValue(JsonToken.Integer);
WriteValueInternal(JsonConvert.ToString(value), JsonToken.Integer);
}
@@ -385,7 +386,7 @@ namespace Newtonsoft.Json
[CLSCompliant(false)]
public override void WriteValue(ushort value)
{
- base.WriteValue(value);
+ InternalWriteValue(JsonToken.Integer);
WriteValueInternal(JsonConvert.ToString(value), JsonToken.Integer);
}
@@ -395,8 +396,8 @@ namespace Newtonsoft.Json
/// The value to write.
public override void WriteValue(char value)
{
- base.WriteValue(value);
- WriteValueInternal(JsonConvert.ToString(value), JsonToken.Integer);
+ InternalWriteValue(JsonToken.String);
+ WriteValueInternal(JsonConvert.ToString(value), JsonToken.String);
}
///
@@ -405,7 +406,7 @@ namespace Newtonsoft.Json
/// The value to write.
public override void WriteValue(byte value)
{
- base.WriteValue(value);
+ InternalWriteValue(JsonToken.Integer);
WriteValueInternal(JsonConvert.ToString(value), JsonToken.Integer);
}
@@ -416,7 +417,7 @@ namespace Newtonsoft.Json
[CLSCompliant(false)]
public override void WriteValue(sbyte value)
{
- base.WriteValue(value);
+ InternalWriteValue(JsonToken.Integer);
WriteValueInternal(JsonConvert.ToString(value), JsonToken.Integer);
}
@@ -426,7 +427,7 @@ namespace Newtonsoft.Json
/// The value to write.
public override void WriteValue(decimal value)
{
- base.WriteValue(value);
+ InternalWriteValue(JsonToken.Float);
WriteValueInternal(JsonConvert.ToString(value), JsonToken.Float);
}
@@ -436,7 +437,7 @@ namespace Newtonsoft.Json
/// The value to write.
public override void WriteValue(DateTime value)
{
- base.WriteValue(value);
+ InternalWriteValue(JsonToken.Date);
value = JsonConvert.EnsureDateTime(value, DateTimeZoneHandling);
JsonConvert.WriteDateTimeString(_writer, value, DateFormatHandling);
}
@@ -447,10 +448,13 @@ namespace Newtonsoft.Json
/// The value to write.
public override void WriteValue(byte[] value)
{
- base.WriteValue(value);
-
- if (value != null)
+ if (value == null)
{
+ WriteNull();
+ }
+ else
+ {
+ InternalWriteValue(JsonToken.Bytes);
_writer.Write(_quoteChar);
Base64Encoder.Encode(value, 0, value.Length);
Base64Encoder.Flush();
@@ -465,7 +469,7 @@ namespace Newtonsoft.Json
/// The value to write.
public override void WriteValue(DateTimeOffset value)
{
- base.WriteValue(value);
+ InternalWriteValue(JsonToken.Date);
WriteValueInternal(JsonConvert.ToString(value, DateFormatHandling), JsonToken.Date);
}
#endif
@@ -476,7 +480,7 @@ namespace Newtonsoft.Json
/// The value to write.
public override void WriteValue(Guid value)
{
- base.WriteValue(value);
+ InternalWriteValue(JsonToken.String);
WriteValueInternal(JsonConvert.ToString(value), JsonToken.String);
}
@@ -486,7 +490,7 @@ namespace Newtonsoft.Json
/// The value to write.
public override void WriteValue(TimeSpan value)
{
- base.WriteValue(value);
+ InternalWriteValue(JsonToken.String);
WriteValueInternal(JsonConvert.ToString(value), JsonToken.String);
}
@@ -496,8 +500,15 @@ namespace Newtonsoft.Json
/// The value to write.
public override void WriteValue(Uri value)
{
- base.WriteValue(value);
- WriteValueInternal(JsonConvert.ToString(value), JsonToken.String);
+ if (value == null)
+ {
+ WriteNull();
+ }
+ else
+ {
+ InternalWriteValue(JsonToken.String);
+ WriteValueInternal(JsonConvert.ToString(value), JsonToken.String);
+ }
}
#endregion
@@ -507,7 +518,7 @@ namespace Newtonsoft.Json
/// Text to place inside the comment.
public override void WriteComment(string text)
{
- base.WriteComment(text);
+ InternalWriteComment();
_writer.Write("/*");
_writer.Write(text);
@@ -520,7 +531,7 @@ namespace Newtonsoft.Json
/// The string of white space characters.
public override void WriteWhitespace(string ws)
{
- base.WriteWhitespace(ws);
+ InternalWriteWhitespace(ws);
_writer.Write(ws);
}
diff --git a/Src/Newtonsoft.Json/JsonWriter.cs b/Src/Newtonsoft.Json/JsonWriter.cs
index 24829505..0a1fa296 100644
--- a/Src/Newtonsoft.Json/JsonWriter.cs
+++ b/Src/Newtonsoft.Json/JsonWriter.cs
@@ -54,7 +54,6 @@ namespace Newtonsoft.Json
Array,
ConstructorStart,
Constructor,
- Bytes,
Closed,
Error
}
@@ -69,7 +68,7 @@ namespace Newtonsoft.Json
/* StartObject */new[]{ State.ObjectStart, State.ObjectStart, State.Error, State.Error, State.ObjectStart, State.ObjectStart, State.ObjectStart, State.ObjectStart, State.Error, State.Error },
/* StartArray */new[]{ State.ArrayStart, State.ArrayStart, State.Error, State.Error, State.ArrayStart, State.ArrayStart, State.ArrayStart, State.ArrayStart, State.Error, State.Error },
/* StartConstructor */new[]{ State.ConstructorStart, State.ConstructorStart, State.Error, State.Error, State.ConstructorStart, State.ConstructorStart, State.ConstructorStart, State.ConstructorStart, State.Error, State.Error },
-/* StartProperty */new[]{ State.Property, State.Error, State.Property, State.Property, State.Error, State.Error, State.Error, State.Error, State.Error, State.Error },
+/* Property */new[]{ State.Property, State.Error, State.Property, State.Property, State.Error, State.Error, State.Error, State.Error, State.Error, State.Error },
/* Comment */new[]{ State.Start, State.Property, State.ObjectStart, State.Object, State.ArrayStart, State.Array, State.Constructor, State.Constructor, State.Error, State.Error },
/* Raw */new[]{ State.Start, State.Property, State.ObjectStart, State.Object, State.ArrayStart, State.Array, State.Constructor, State.Constructor, State.Error, State.Error },
/* Value (this will be copied) */new[]{ State.Start, State.Object, State.Error, State.Error, State.Array, State.Array, State.Constructor, State.Constructor, State.Error, State.Error }
@@ -142,7 +141,7 @@ namespace Newtonsoft.Json
return depth;
}
}
-
+
///
/// Gets the state of the writer.
///
@@ -304,10 +303,15 @@ namespace Newtonsoft.Json
/// Writes the beginning of a Json object.
///
public virtual void WriteStartObject()
+ {
+ InternalWriteStart(JsonToken.StartObject, JsonContainerType.Object);
+ }
+
+ internal void InternalWriteStart(JsonToken token, JsonContainerType container)
{
UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.StartObject);
- Push(JsonContainerType.Object);
+ AutoComplete(token);
+ Push(container);
}
///
@@ -315,7 +319,7 @@ namespace Newtonsoft.Json
///
public virtual void WriteEndObject()
{
- AutoCompleteClose(JsonContainerType.Object);
+ InternalWriteEnd(JsonContainerType.Object);
}
///
@@ -323,9 +327,7 @@ namespace Newtonsoft.Json
///
public virtual void WriteStartArray()
{
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.StartArray);
- Push(JsonContainerType.Array);
+ InternalWriteStart(JsonToken.StartArray, JsonContainerType.Array);
}
///
@@ -333,7 +335,7 @@ namespace Newtonsoft.Json
///
public virtual void WriteEndArray()
{
- AutoCompleteClose(JsonContainerType.Array);
+ InternalWriteEnd(JsonContainerType.Array);
}
///
@@ -342,9 +344,7 @@ namespace Newtonsoft.Json
/// The name of the constructor.
public virtual void WriteStartConstructor(string name)
{
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.StartConstructor);
- Push(JsonContainerType.Constructor);
+ InternalWriteStart(JsonToken.StartConstructor, JsonContainerType.Constructor);
}
///
@@ -352,7 +352,12 @@ namespace Newtonsoft.Json
///
public virtual void WriteEndConstructor()
{
- AutoCompleteClose(JsonContainerType.Constructor);
+ InternalWriteEnd(JsonContainerType.Constructor);
+ }
+
+ internal void InternalWriteEnd(JsonContainerType container)
+ {
+ AutoCompleteClose(container);
}
///
@@ -360,6 +365,11 @@ namespace Newtonsoft.Json
///
/// The name of the property.
public virtual void WritePropertyName(string name)
+ {
+ InternalWritePropertyName(name);
+ }
+
+ internal void InternalWritePropertyName(string name)
{
_currentPosition.PropertyName = name;
AutoComplete(JsonToken.PropertyName);
@@ -672,22 +682,16 @@ namespace Newtonsoft.Json
{
WriteValueDelimiter();
}
- else if (_currentState == State.Property)
- {
- if (_formatting == Formatting.Indented)
- WriteIndentSpace();
- }
if (_formatting == Formatting.Indented)
{
- WriteState writeState = WriteState;
+ if (_currentState == State.Property)
+ WriteIndentSpace();
// don't indent a property when it is the first token to be written (i.e. at the start)
- if ((tokenBeingWritten == JsonToken.PropertyName && writeState != WriteState.Start) ||
- writeState == WriteState.Array || writeState == WriteState.Constructor)
- {
+ if ((_currentState == State.Array || _currentState == State.ArrayStart || _currentState == State.Constructor || _currentState == State.ConstructorStart)
+ || (tokenBeingWritten == JsonToken.PropertyName && _currentState != State.Start))
WriteIndent();
- }
}
_currentState = newState;
@@ -698,6 +702,11 @@ namespace Newtonsoft.Json
/// Writes a null value.
///
public virtual void WriteNull()
+ {
+ InternalWriteNull();
+ }
+
+ internal void InternalWriteNull()
{
UpdateScopeWithFinishedValue();
AutoComplete(JsonToken.Null);
@@ -707,6 +716,11 @@ namespace Newtonsoft.Json
/// Writes an undefined value.
///
public virtual void WriteUndefined()
+ {
+ InternalWriteUndefined();
+ }
+
+ internal void InternalWriteUndefined()
{
UpdateScopeWithFinishedValue();
AutoComplete(JsonToken.Undefined);
@@ -717,6 +731,11 @@ namespace Newtonsoft.Json
///
/// The raw JSON to write.
public virtual void WriteRaw(string json)
+ {
+ InternalWriteRaw();
+ }
+
+ internal void InternalWriteRaw()
{
}
@@ -737,9 +756,14 @@ namespace Newtonsoft.Json
///
/// The value to write.
public virtual void WriteValue(string value)
+ {
+ InternalWriteValue(JsonToken.String);
+ }
+
+ internal void InternalWriteValue(JsonToken token)
{
UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.String);
+ AutoComplete(token);
}
///
@@ -748,8 +772,7 @@ namespace Newtonsoft.Json
/// The value to write.
public virtual void WriteValue(int value)
{
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.Integer);
+ InternalWriteValue(JsonToken.Integer);
}
///
@@ -759,8 +782,7 @@ namespace Newtonsoft.Json
[CLSCompliant(false)]
public virtual void WriteValue(uint value)
{
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.Integer);
+ InternalWriteValue(JsonToken.Integer);
}
///
@@ -769,8 +791,7 @@ namespace Newtonsoft.Json
/// The value to write.
public virtual void WriteValue(long value)
{
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.Integer);
+ InternalWriteValue(JsonToken.Integer);
}
///
@@ -780,8 +801,7 @@ namespace Newtonsoft.Json
[CLSCompliant(false)]
public virtual void WriteValue(ulong value)
{
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.Integer);
+ InternalWriteValue(JsonToken.Integer);
}
///
@@ -790,8 +810,7 @@ namespace Newtonsoft.Json
/// The value to write.
public virtual void WriteValue(float value)
{
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.Float);
+ InternalWriteValue(JsonToken.Float);
}
///
@@ -800,8 +819,7 @@ namespace Newtonsoft.Json
/// The value to write.
public virtual void WriteValue(double value)
{
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.Float);
+ InternalWriteValue(JsonToken.Float);
}
///
@@ -810,8 +828,7 @@ namespace Newtonsoft.Json
/// The value to write.
public virtual void WriteValue(bool value)
{
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.Boolean);
+ InternalWriteValue(JsonToken.Boolean);
}
///
@@ -820,8 +837,7 @@ namespace Newtonsoft.Json
/// The value to write.
public virtual void WriteValue(short value)
{
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.Integer);
+ InternalWriteValue(JsonToken.Integer);
}
///
@@ -831,8 +847,7 @@ namespace Newtonsoft.Json
[CLSCompliant(false)]
public virtual void WriteValue(ushort value)
{
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.Integer);
+ InternalWriteValue(JsonToken.Integer);
}
///
@@ -841,8 +856,7 @@ namespace Newtonsoft.Json
/// The value to write.
public virtual void WriteValue(char value)
{
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.String);
+ InternalWriteValue(JsonToken.String);
}
///
@@ -851,8 +865,7 @@ namespace Newtonsoft.Json
/// The value to write.
public virtual void WriteValue(byte value)
{
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.Integer);
+ InternalWriteValue(JsonToken.Integer);
}
///
@@ -862,8 +875,7 @@ namespace Newtonsoft.Json
[CLSCompliant(false)]
public virtual void WriteValue(sbyte value)
{
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.Integer);
+ InternalWriteValue(JsonToken.Integer);
}
///
@@ -872,8 +884,7 @@ namespace Newtonsoft.Json
/// The value to write.
public virtual void WriteValue(decimal value)
{
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.Float);
+ InternalWriteValue(JsonToken.Float);
}
///
@@ -882,8 +893,7 @@ namespace Newtonsoft.Json
/// The value to write.
public virtual void WriteValue(DateTime value)
{
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.Date);
+ InternalWriteValue(JsonToken.Date);
}
#if !PocketPC && !NET20
@@ -893,8 +903,7 @@ namespace Newtonsoft.Json
/// The value to write.
public virtual void WriteValue(DateTimeOffset value)
{
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.Date);
+ InternalWriteValue(JsonToken.Date);
}
#endif
@@ -904,8 +913,7 @@ namespace Newtonsoft.Json
/// The value to write.
public virtual void WriteValue(Guid value)
{
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.String);
+ InternalWriteValue(JsonToken.String);
}
///
@@ -914,8 +922,7 @@ namespace Newtonsoft.Json
/// The value to write.
public virtual void WriteValue(TimeSpan value)
{
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.String);
+ InternalWriteValue(JsonToken.String);
}
///
@@ -1135,14 +1142,9 @@ namespace Newtonsoft.Json
public virtual void WriteValue(byte[] value)
{
if (value == null)
- {
WriteNull();
- }
else
- {
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.Bytes);
- }
+ InternalWriteValue(JsonToken.Bytes);
}
///
@@ -1152,14 +1154,9 @@ namespace Newtonsoft.Json
public virtual void WriteValue(Uri value)
{
if (value == null)
- {
WriteNull();
- }
else
- {
- UpdateScopeWithFinishedValue();
- AutoComplete(JsonToken.String);
- }
+ InternalWriteValue(JsonToken.String);
}
///
@@ -1270,7 +1267,11 @@ namespace Newtonsoft.Json
/// Text to place inside the comment.
public virtual void WriteComment(string text)
{
- UpdateScopeWithFinishedValue();
+ InternalWriteComment();
+ }
+
+ internal void InternalWriteComment()
+ {
AutoComplete(JsonToken.Comment);
}
@@ -1279,6 +1280,11 @@ namespace Newtonsoft.Json
///
/// The string of white space characters.
public virtual void WriteWhitespace(string ws)
+ {
+ InternalWriteWhitespace(ws);
+ }
+
+ internal void InternalWriteWhitespace(string ws)
{
if (ws != null)
{
@@ -1287,7 +1293,6 @@ namespace Newtonsoft.Json
}
}
-
void IDisposable.Dispose()
{
Dispose(true);
diff --git a/Src/Newtonsoft.Json/Properties/AssemblyInfo.cs b/Src/Newtonsoft.Json/Properties/AssemblyInfo.cs
index 715b0c5c..3db07c51 100644
--- a/Src/Newtonsoft.Json/Properties/AssemblyInfo.cs
+++ b/Src/Newtonsoft.Json/Properties/AssemblyInfo.cs
@@ -90,7 +90,7 @@ using System.Security;
// by using the '*' as shown below:
[assembly: AssemblyVersion("4.5.0.0")]
#if !PocketPC
-[assembly: AssemblyFileVersion("4.5.10.15427")]
+[assembly: AssemblyFileVersion("4.5.10.15501")]
#endif
[assembly: CLSCompliant(true)]