-Fixed deserializing a null string throwing a NullReferenceException

-Fixed JsonTextReader reading from a slow stream
-Fixed CultureInfo not being overridden on JsonSerializerProxy
-Fixed full trust security check in .NET 2.0 & .NET 3.5
-Improved writing JSON with indent performance

Src/Newtonsoft.Json.Tests/JsonConvertTest.cs

@@ -114,6 +114,20 @@ namespace Newtonsoft.Json.Tests
     }
 #endif
 
+    [Test]
+    public void DeserializeObject_EmptyString()
+    {
+      object result = JsonConvert.DeserializeObject(string.Empty);
+      Assert.IsNull(result);
+    }
+
+    [Test]
+    public void DeserializeObject_Integer()
+    {
+      object result = JsonConvert.DeserializeObject("1");
+      Assert.AreEqual(1L, result);
+    }
+
     [Test]
     public void EscapeJavaScriptString()
     {

Src/Newtonsoft.Json.Tests/JsonTextReaderTest.cs

@@ -100,7 +100,7 @@ namespace Newtonsoft.Json.Tests
     {
       string json = @"{""DefaultConverter"":new Date(0, ""hi""),""MemberConverter"":""1970-01-01T00:00:00Z""}";
 
-      JsonReader reader = new JsonTextReader(new StringReader(json));
+      JsonReader reader = new JsonTextReader(new StreamReader(new SlowStream(json, new UTF8Encoding(false), 1)));
 
       Assert.IsTrue(reader.Read());
       Assert.IsTrue(reader.Read());
@@ -479,7 +479,7 @@ Parameter name: reader"
     public void NullCharReading()
     {
       string json = "\0{\0'\0h\0i\0'\0:\0[\01\0,\0'\0'\0\0,\0null\0]\0,\0do\0:true\0}\0\0/*\0sd\0f\0*/\0/*\0sd\0f\0*/ \0";
-      JsonTextReader reader = new JsonTextReader(new StringReader(json));
+      JsonTextReader reader = new JsonTextReader(new StreamReader(new SlowStream(json, new UTF8Encoding(false), 1)));
 
       Assert.IsTrue(reader.Read());
       Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
@@ -710,7 +710,7 @@ Parameter name: reader"
         count++;
       }
 
-      JsonTextReader reader = new JsonTextReader(new StringReader(json));
+      JsonTextReader reader = new JsonTextReader(new StreamReader(new SlowStream(json, new UTF8Encoding(false), 1)));
       Assert.IsTrue(reader.Read());
       Assert.AreEqual(7, reader.LineNumber);
 
@@ -1966,7 +1966,7 @@ bye", reader.Value);
     public void ParseContentDelimitedByNonStandardWhitespace()
     {
       string json = "\x00a0{\x00a0'h\x00a0i\x00a0'\x00a0:\x00a0[\x00a0true\x00a0,\x00a0new\x00a0Date\x00a0(\x00a0)\x00a0]\x00a0/*\x00a0comment\x00a0*/\x00a0}\x00a0";
-      JsonTextReader reader = new JsonTextReader(new StringReader(json));
+      JsonTextReader reader = new JsonTextReader(new StreamReader(new SlowStream(json, new UTF8Encoding(false), 1)));
 
       Assert.IsTrue(reader.Read());
       Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
@@ -2010,7 +2010,7 @@ bye", reader.Value);
         ""Sizes"":/*comment*/[/*comment*/
           ""Small""/*comment*/]/*comment*/}/*comment*/";
 
-      JsonTextReader reader = new JsonTextReader(new StringReader(json));
+      JsonTextReader reader = new JsonTextReader(new StreamReader(new SlowStream(json, new UTF8Encoding(false), 1)));
 
       Assert.IsTrue(reader.Read());
       Assert.AreEqual(JsonToken.Comment, reader.TokenType);
@@ -2194,5 +2194,141 @@ bye", reader.Value);
 
       reader.Read();
     }
+
+    [Test]
+    public void ReadingFromSlowStream()
+    {
+      string json = "[false, true, true, false, 'test!', 1.11, 0e-10, 0E-10, 0.25e-5, 0.3e10, 6.0221418e23, 'Purple\\r \\n monkey\\'s:\\tdishwasher']";
+
+      JsonTextReader reader = new JsonTextReader(new StreamReader(new SlowStream(json, new UTF8Encoding(false), 1)));
+
+      Assert.IsTrue(reader.Read());
+
+      Assert.IsTrue(reader.Read());
+      Assert.AreEqual(false, reader.Value);
+
+      Assert.IsTrue(reader.Read());
+      Assert.AreEqual(JsonToken.Boolean, reader.TokenType);
+      Assert.AreEqual(true, reader.Value);
+
+      Assert.IsTrue(reader.Read());
+      Assert.AreEqual(JsonToken.Boolean, reader.TokenType);
+      Assert.AreEqual(true, reader.Value);
+
+      Assert.IsTrue(reader.Read());
+      Assert.AreEqual(JsonToken.Boolean, reader.TokenType);
+      Assert.AreEqual(false, reader.Value);
+
+      Assert.IsTrue(reader.Read());
+      Assert.AreEqual(JsonToken.String, reader.TokenType);
+      Assert.AreEqual("test!", reader.Value);
+
+      Assert.IsTrue(reader.Read());
+      Assert.AreEqual(JsonToken.Float, reader.TokenType);
+      Assert.AreEqual(1.11d, reader.Value);
+
+      Assert.IsTrue(reader.Read());
+      Assert.AreEqual(JsonToken.Float, reader.TokenType);
+      Assert.AreEqual(0d, reader.Value);
+
+      Assert.IsTrue(reader.Read());
+      Assert.AreEqual(JsonToken.Float, reader.TokenType);
+      Assert.AreEqual(0d, reader.Value);
+
+      Assert.IsTrue(reader.Read());
+      Assert.AreEqual(JsonToken.Float, reader.TokenType);
+      Assert.AreEqual(0.0000025d, reader.Value);
+
+      Assert.IsTrue(reader.Read());
+      Assert.AreEqual(JsonToken.Float, reader.TokenType);
+      Assert.AreEqual(3000000000d, reader.Value);
+
+      Assert.IsTrue(reader.Read());
+      Assert.AreEqual(JsonToken.Float, reader.TokenType);
+      Assert.AreEqual(602214180000000000000000d, reader.Value);
+
+      Assert.IsTrue(reader.Read());
+      Assert.AreEqual(JsonToken.String, reader.TokenType);
+      Assert.AreEqual(reader.Value, "Purple\r \n monkey's:\tdishwasher");
+
+      Assert.IsTrue(reader.Read());
+    }
+  }
+
+  public class SlowStream : Stream
+  {
+    byte[] bytes;
+    int totalBytesRead;
+    int bytesPerRead;
+
+    public SlowStream(byte[] content, int bytesPerRead)
+    {
+      this.bytes = content;
+      this.totalBytesRead = 0;
+      this.bytesPerRead = bytesPerRead;
+    }
+
+    public SlowStream(string content, Encoding encoding, int bytesPerRead)
+      : this(encoding.GetBytes(content), bytesPerRead)
+    {
+    }
+
+    public override bool CanRead
+    {
+      get { return true; }
+    }
+
+    public override bool CanSeek
+    {
+      get { return false; }
+    }
+
+    public override bool CanWrite
+    {
+      get { return false; }
+    }
+
+    public override void Flush()
+    {
+    }
+
+    public override long Length
+    {
+      get { throw new NotSupportedException(); }
+    }
+
+    public override long Position
+    {
+      get { throw new NotSupportedException(); }
+      set { throw new NotSupportedException(); }
+    }
+
+    public override int Read(byte[] buffer, int offset, int count)
+    {
+      int toReturn = Math.Min(count, this.bytesPerRead);
+      toReturn = Math.Min(toReturn, this.bytes.Length - this.totalBytesRead);
+      if (toReturn > 0)
+      {
+        Array.Copy(this.bytes, this.totalBytesRead, buffer, offset, toReturn);
+      }
+
+      this.totalBytesRead += toReturn;
+      return toReturn;
+    }
+
+    public override long Seek(long offset, SeekOrigin origin)
+    {
+      throw new NotSupportedException();
+    }
+
+    public override void SetLength(long value)
+    {
+      throw new NotSupportedException();
+    }
+
+    public override void Write(byte[] buffer, int offset, int count)
+    {
+      throw new NotSupportedException();
+    }
   }
 }

Src/Newtonsoft.Json.Tests/Properties/AssemblyInfo.cs

@@ -1,76 +0,0 @@
-#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
-
-using System.Reflection;
-using System.Runtime.InteropServices;
-using System.Security;
-
-// General Information about an assembly is controlled through the following 
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
-
-#if WINDOWS_PHONE
-[assembly: AssemblyTitle("Json.NET Tests Windows Phone")]
-#elif SILVERLIGHT
-[assembly: AssemblyTitle("Json.NET Tests Silverlight")]
-#elif PocketPC
-[assembly: AssemblyTitle("Json.NET Tests Compact")]
-#elif NET20
-[assembly: AssemblyTitle("Json.NET Tests .NET 2.0")]
-#elif NET35
-[assembly: AssemblyTitle("Json.NET Tests .NET 3.5")]
-#else
-[assembly: AssemblyTitle("Json.NET")]
-#endif
-
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("Newtonsoft")]
-[assembly: AssemblyProduct("Json.NET Tests")]
-[assembly: AssemblyCopyright("Copyright © James Newton-King 2008")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-// Setting ComVisible to false makes the types in this assembly not visible 
-// to COM components.  If you need to access a type in this assembly from 
-// COM, set the ComVisible attribute to true on that type.
-[assembly: ComVisible(false)]
-
-// The following GUID is for the ID of the typelib if this project is exposed to COM
-[assembly: Guid("0be3d72b-d2ef-409c-985c-d3ede89a25f1")]
-
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version 
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Revision and Build Numbers 
-// by using the '*' as shown below:
-[assembly: AssemblyVersion("4.0.8.0")]
-#if !PocketPC
-[assembly: AssemblyFileVersion("4.0.8.14718")]
-#endif

Src/Newtonsoft.Json.Tests/Serialization/ContractResolverTests.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.Serialization;
 using System.Text;
 #if !NETFX_CORE
 using NUnit.Framework;
@@ -58,9 +59,25 @@ namespace Newtonsoft.Json.Tests.Serialization
     }
   }
 
+  public class AddressWithDataMember
+  {
+    [DataMember(Name = "CustomerAddress1")]
+    public string AddressLine1 { get; set; }
+
+  }
+
   [TestFixture]
   public class ContractResolverTests : TestFixtureBase
   {
+    [Test]
+    public void DeserializeDataMemberClassWithNoDataContract()
+    {
+      var resolver = new DefaultContractResolver();
+      var contract = (JsonObjectContract)resolver.ResolveContract(typeof(AddressWithDataMember));
+
+      Assert.AreEqual("AddressLine1", contract.Properties[0].PropertyName);
+    }
+
     [Test]
     public void ResolveProperties_IgnoreStatic()
     {

Src/Newtonsoft.Json/JsonTextReader.cs

@@ -343,9 +343,23 @@ namespace Newtonsoft.Json
 
       int charsRequired = _charPos + relativePosition - _charsUsed + 1;
 
-      int charsRead = ReadData(append, charsRequired);
+      int totalCharsRead = 0;
 
-      if (charsRead < charsRequired)
+      // it is possible that the TextReader doesn't return all data at once
+      // repeat read until the required text is returned or the reader is out of content
+      do
+      {
+        int charsRead = ReadData(append, charsRequired - totalCharsRead);
+
+        // no more content
+        if (charsRead == 0)
+          break;
+
+        totalCharsRead += charsRead;
+      }
+      while (totalCharsRead < charsRequired);
+
+      if (totalCharsRead < charsRequired)
         return false;
       return true;
     }

Src/Newtonsoft.Json/JsonTextWriter.cs

@@ -221,9 +221,14 @@ namespace Newtonsoft.Json
       // levels of indentation multiplied by the indent count
       int currentIndentCount = Top*_indentation;
 
-      for (int i = 0; i < currentIndentCount; i++)
+      while (currentIndentCount > 0)
       {
-        _writer.Write(_indentChar);
+        // write up to a max of 10 characters at once to avoid creating too many new strings
+        int writeCount = Math.Min(currentIndentCount, 10);
+
+        _writer.Write(new string(_indentChar, writeCount));
+
+        currentIndentCount -= writeCount;
       }
     }
 

Src/Newtonsoft.Json/Properties/AssemblyInfo.cs

@@ -85,7 +85,7 @@ using System.Security;
 // by using the '*' as shown below:
 [assembly: AssemblyVersion("4.0.8.0")]
 #if !PocketPC
-[assembly: AssemblyFileVersion("4.0.8.14718")]
+[assembly: AssemblyFileVersion("4.0.8.14731")]
 #endif
 
 [assembly: CLSCompliant(true)]

Src/Newtonsoft.Json/Serialization/JsonSerializerInternalReader.cs

@@ -117,7 +117,7 @@ namespace Newtonsoft.Json.Serialization
 
       if (reader.TokenType == JsonToken.None && !ReadForType(reader, contract, converter != null, false))
       {
-        if (!contract.IsNullable)
+        if (contract != null && !contract.IsNullable)
           throw new JsonSerializationException("No JSON content found and type '{0}' is not nullable.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
 
         return null;

Src/Newtonsoft.Json/Serialization/JsonSerializerInternalWriter.cs

@@ -137,7 +137,7 @@ namespace Newtonsoft.Json.Serialization
           break;
 #if !(NET35 || NET20 || WINDOWS_PHONE)
         case JsonContractType.Dynamic:
-          SerializeDynamic(writer, (IDynamicMetaObjectProvider) value, (JsonDynamicContract) valueContract);
+          SerializeDynamic(writer, (IDynamicMetaObjectProvider) value, (JsonDynamicContract) valueContract, member, collectionValueContract);
           break;
 #endif
 #if !SILVERLIGHT && !PocketPC && !NETFX_CORE
@@ -184,15 +184,6 @@ namespace Newtonsoft.Json.Serialization
     private void WriteMemberInfoProperty(JsonWriter writer, object memberValue, JsonProperty property, JsonContract contract)
     {
       string propertyName = property.PropertyName;
-      object defaultValue = property.DefaultValue;
-
-      if (property.NullValueHandling.GetValueOrDefault(Serializer.NullValueHandling) == NullValueHandling.Ignore &&
-          memberValue == null)
-        return;
-
-      if (HasFlag(property.DefaultValueHandling.GetValueOrDefault(Serializer.DefaultValueHandling), DefaultValueHandling.Ignore)
-        && MiscellaneousUtils.ValueEquals(memberValue, defaultValue))
-        return;
 
       if (ShouldWriteReference(memberValue, property, contract))
       {
@@ -211,6 +202,19 @@ namespace Newtonsoft.Json.Serialization
       SerializeValue(writer, memberValue, contract, property, null);
     }
 
+    private bool ShouldWriteProperty(object memberValue, JsonProperty property)
+    {
+      if (property.NullValueHandling.GetValueOrDefault(Serializer.NullValueHandling) == NullValueHandling.Ignore &&
+          memberValue == null)
+        return false;
+
+      if (HasFlag(property.DefaultValueHandling.GetValueOrDefault(Serializer.DefaultValueHandling), DefaultValueHandling.Ignore)
+          && MiscellaneousUtils.ValueEquals(memberValue, property.DefaultValue))
+        return false;
+
+      return true;
+    }
+
     private bool CheckForCircularReference(object value, ReferenceLoopHandling? referenceLoopHandling, JsonContract contract)
     {
       if (value == null || contract.ContractType == JsonContractType.Primitive || contract.ContractType == JsonContractType.String)
@@ -300,18 +304,8 @@ namespace Newtonsoft.Json.Serialization
       contract.InvokeOnSerializing(value, Serializer.Context);
 
       _serializeStack.Add(value);
-      writer.WriteStartObject();
 
-      bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Objects);
-      if (isReference)
-      {
-        writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
-        writer.WriteValue(Serializer.ReferenceResolver.GetReference(this, value));
-      }
-      if (ShouldWriteType(TypeNameHandling.Objects, contract, member, collectionValueContract))
-      {
-        WriteTypeProperty(writer, contract.UnderlyingType);
-      }
+      WriteObjectStart(writer, value, contract, member, collectionValueContract);
 
       int initialDepth = writer.Top;
 
@@ -327,7 +321,10 @@ namespace Newtonsoft.Json.Serialization
             object memberValue = property.ValueProvider.GetValue(value);
             JsonContract memberContract = (property.PropertyContract.UnderlyingType.IsSealed()) ? property.PropertyContract : GetContractSafe(memberValue);
 
-            WriteMemberInfoProperty(writer, memberValue, property, memberContract);
+            if (ShouldWriteProperty(memberValue, property))
+            {
+              WriteMemberInfoProperty(writer, memberValue, property, memberContract);
+            }
           }
         }
         catch (Exception ex)
@@ -340,11 +337,28 @@ namespace Newtonsoft.Json.Serialization
       }
 
       writer.WriteEndObject();
+
       _serializeStack.RemoveAt(_serializeStack.Count - 1);
 
       contract.InvokeOnSerialized(value, Serializer.Context);
     }
 
+    private void WriteObjectStart(JsonWriter writer, object value, JsonContract contract, JsonProperty member, JsonContract collectionValueContract)
+    {
+      writer.WriteStartObject();
+      
+      bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Objects);
+      if (isReference)
+      {
+        writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
+        writer.WriteValue(Serializer.ReferenceResolver.GetReference(this, value));
+      }
+      if (ShouldWriteType(TypeNameHandling.Objects, contract, member, collectionValueContract))
+      {
+        WriteTypeProperty(writer, contract.UnderlyingType);
+      }
+    }
+
     private void WriteTypeProperty(JsonWriter writer, Type type)
     {
       writer.WritePropertyName(JsonTypeReflector.TypePropertyName);
@@ -391,32 +405,12 @@ namespace Newtonsoft.Json.Serialization
 
       _serializeStack.Add(values.UnderlyingCollection);
 
-      bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays);
-      bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Arrays, contract, member, collectionValueContract);
-
-      if (isReference || includeTypeDetails)
-      {
-        writer.WriteStartObject();
-
-        if (isReference)
-        {
-          writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
-          writer.WriteValue(Serializer.ReferenceResolver.GetReference(this, values.UnderlyingCollection));
-        }
-        if (includeTypeDetails)
-        {
-          WriteTypeProperty(writer, values.UnderlyingCollection.GetType());
-        }
-        writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName);
-      }
-
-      if (contract.CollectionItemContract == null)
-        contract.CollectionItemContract = Serializer.ContractResolver.ResolveContract(contract.CollectionItemType ?? typeof(object));
-
-      JsonContract collectionItemValueContract = (contract.CollectionItemContract.UnderlyingType.IsSealed()) ? contract.CollectionItemContract : null;
+      bool hasWrittenMetadataObject = WriteStartArray(writer, values, contract, member, collectionValueContract);
 
       writer.WriteStartArray();
 
+      JsonContract collectionItemValueContract = (contract.CollectionItemContract.UnderlyingType.IsSealed()) ? contract.CollectionItemContract : null;
+
       int initialDepth = writer.Top;
 
       int index = 0;
@@ -454,16 +448,42 @@ namespace Newtonsoft.Json.Serialization
 
       writer.WriteEndArray();
 
-      if (isReference || includeTypeDetails)
-      {
+      if (hasWrittenMetadataObject)
         writer.WriteEndObject();
-      }
 
       _serializeStack.RemoveAt(_serializeStack.Count - 1);
 
       contract.InvokeOnSerialized(values.UnderlyingCollection, Serializer.Context);
     }
 
+    private bool WriteStartArray(JsonWriter writer, IWrappedCollection values, JsonArrayContract contract, JsonProperty member, JsonContract collectionValueContract)
+    {
+      bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Arrays);
+      bool includeTypeDetails = ShouldWriteType(TypeNameHandling.Arrays, contract, member, collectionValueContract);
+      bool writeMetadataObject = isReference || includeTypeDetails;
+
+      if (writeMetadataObject)
+      {
+        writer.WriteStartObject();
+
+        if (isReference)
+        {
+          writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
+          writer.WriteValue(Serializer.ReferenceResolver.GetReference(this, values.UnderlyingCollection));
+        }
+        if (includeTypeDetails)
+        {
+          WriteTypeProperty(writer, values.UnderlyingCollection.GetType());
+        }
+        writer.WritePropertyName(JsonTypeReflector.ArrayValuesPropertyName);
+      }
+
+      if (contract.CollectionItemContract == null)
+        contract.CollectionItemContract = Serializer.ContractResolver.ResolveContract(contract.CollectionItemType ?? typeof (object));
+
+      return writeMetadataObject;
+    }
+
 #if !SILVERLIGHT && !PocketPC && !NETFX_CORE
 #if !NET20
     [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Portability", "CA1903:UseOnlyApiFromTargetedFramework", MessageId = "System.Security.SecuritySafeCriticalAttribute")]
@@ -480,12 +500,7 @@ To fix this error either change the environment to be fully trusted, change the
       contract.InvokeOnSerializing(value, Serializer.Context);
       _serializeStack.Add(value);
 
-      writer.WriteStartObject();
-
-      if (ShouldWriteType(TypeNameHandling.Objects, contract, member, collectionValueContract))
-      {
-          WriteTypeProperty(writer, contract.UnderlyingType);
-      }
+      WriteObjectStart(writer, value, contract, member, collectionValueContract);
 
       SerializationInfo serializationInfo = new SerializationInfo(contract.UnderlyingType, new FormatterConverter());
       value.GetObjectData(serializationInfo, Serializer.Context);
@@ -504,18 +519,12 @@ To fix this error either change the environment to be fully trusted, change the
 #endif
 
 #if !(NET35 || NET20 || WINDOWS_PHONE)
-    /// <summary>
-    /// Serializes the dynamic.
-    /// </summary>
-    /// <param name="writer">The writer.</param>
-    /// <param name="value">The value.</param>
-    /// <param name="contract">The contract.</param>
-    private void SerializeDynamic(JsonWriter writer, IDynamicMetaObjectProvider value, JsonDynamicContract contract)
+    private void SerializeDynamic(JsonWriter writer, IDynamicMetaObjectProvider value, JsonDynamicContract contract, JsonProperty member, JsonContract collectionValueContract)
     {
       contract.InvokeOnSerializing(value, Serializer.Context);
       _serializeStack.Add(value);
 
-      writer.WriteStartObject();
+      WriteObjectStart(writer, value, contract, member, collectionValueContract);
 
       foreach (string memberName in value.GetDynamicMemberNames())
       {
@@ -523,9 +532,9 @@ To fix this error either change the environment to be fully trusted, change the
         if (DynamicUtils.TryGetMember(value, memberName, out memberValue))
         {
           string resolvedPropertyName = (contract.PropertyNameResolver != null)
-            ? contract.PropertyNameResolver(memberName)
-            : memberName;
-          
+                                          ? contract.PropertyNameResolver(memberName)
+                                          : memberName;
+
           writer.WritePropertyName(resolvedPropertyName);
           SerializeValue(writer, memberValue, GetContractSafe(memberValue), null, null);
         }
@@ -569,18 +578,8 @@ To fix this error either change the environment to be fully trusted, change the
       contract.InvokeOnSerializing(values.UnderlyingDictionary, Serializer.Context);
 
       _serializeStack.Add(values.UnderlyingDictionary);
-      writer.WriteStartObject();
 
-      bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Objects);
-      if (isReference)
-      {
-        writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
-        writer.WriteValue(Serializer.ReferenceResolver.GetReference(this, values.UnderlyingDictionary));
-      }
-      if (ShouldWriteType(TypeNameHandling.Objects, contract, member, collectionValueContract))
-      {
-        WriteTypeProperty(writer, values.UnderlyingDictionary.GetType());
-      }
+      WriteObjectStart(writer, values.UnderlyingDictionary, contract, member, collectionValueContract);
 
       if (contract.DictionaryValueContract == null)
         contract.DictionaryValueContract = Serializer.ContractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object));
@@ -589,12 +588,8 @@ To fix this error either change the environment to be fully trusted, change the
 
       int initialDepth = writer.Top;
 
-#if !NETFX_CORE
       // Mono Unity 3.0 fix
-      IDictionary d = values;
-#else
       IWrappedDictionary d = values;
-#endif
 
       foreach (DictionaryEntry entry in d)
       {
@@ -634,6 +629,7 @@ To fix this error either change the environment to be fully trusted, change the
       }
 
       writer.WriteEndObject();
+
       _serializeStack.RemoveAt(_serializeStack.Count - 1);
 
       contract.InvokeOnSerialized(values.UnderlyingDictionary, Serializer.Context);

Src/Newtonsoft.Json/Serialization/JsonSerializerProxy.cs

@@ -144,6 +144,12 @@ namespace Newtonsoft.Json.Serialization
       set { _serializer.DateTimeZoneHandling = value; }
     }
 
+    public override CultureInfo Culture
+    {
+      get { return _serializer.Culture; }
+      set { _serializer.Culture = value; }
+    }
+
     internal JsonSerializerInternalBase GetInternalSerializer()
     {
       if (_serializerReader != null)

Src/Newtonsoft.Json/Serialization/JsonTypeReflector.cs

@@ -28,7 +28,6 @@ using System.ComponentModel;
 using System.Globalization;
 using System.Reflection;
 #if !NETFX_CORE
-using System.Runtime.Serialization;
 using System.Security.Permissions;
 #endif
 using Newtonsoft.Json.Utilities;
@@ -40,6 +39,7 @@ using Newtonsoft.Json.Utilities.LinqBridge;
 #else
 using System.Linq;
 #endif
+using System.Runtime.Serialization;
 
 namespace Newtonsoft.Json.Serialization
 {
@@ -102,7 +102,7 @@ namespace Newtonsoft.Json.Serialization
       return GetJsonContainerAttribute(type) as JsonArrayAttribute;
     }
 
-#if !PocketPC && !NET20 
+#if !PocketPC && !NET20
     public static DataContractAttribute GetDataContractAttribute(Type type)
     {
       // DataContractAttribute does not have inheritance
@@ -126,7 +126,7 @@ namespace Newtonsoft.Json.Serialization
         return CachedAttributeGetter<DataMemberAttribute>.GetAttribute(memberInfo.GetCustomAttributeProvider());
 
       // search property and then search base properties if nothing is returned and the property is virtual
-      PropertyInfo propertyInfo = (PropertyInfo) memberInfo;
+      PropertyInfo propertyInfo = (PropertyInfo)memberInfo;
       DataMemberAttribute result = CachedAttributeGetter<DataMemberAttribute>.GetAttribute(propertyInfo.GetCustomAttributeProvider());
       if (result == null)
       {
@@ -259,7 +259,7 @@ namespace Newtonsoft.Json.Serialization
         else
           return null;
       }
-      
+
       return _cachedMetadataTypeAttributeType;
     }
 #endif
@@ -403,12 +403,22 @@ namespace Newtonsoft.Json.Serialization
       {
         if (_fullyTrusted == null)
         {
-#if !(NET20 || NET35 || SILVERLIGHT)
+#if (NETFX_CORE || SILVERLIGHT)
+          _fullyTrusted = false;
+#elif !(NET20 || NET35)
           AppDomain appDomain = AppDomain.CurrentDomain;
 
           _fullyTrusted = appDomain.IsHomogenous && appDomain.IsFullyTrusted;
 #else
-          _fullyTrusted = true;
+          try
+          {
+            new SecurityPermission(PermissionState.Unrestricted).Demand();
+            _fullyTrusted = true;
+          }
+          catch (Exception)
+          {
+            _fullyTrusted = false;
+          }
 #endif
         }
 

Src/Newtonsoft.Json/TypeNameHandling.cs

@@ -21,12 +21,12 @@ namespace Newtonsoft.Json
     /// </summary>
     Arrays = 2,
     /// <summary>
-    /// Include the .NET type name when the type of the object being serialized is not the same as its declared type.
-    /// </summary>
-    Auto = 4,
-    /// <summary>
     /// Always include the .NET type name when serializing.
     /// </summary>
-    All = Objects | Arrays
+    All = Objects | Arrays,
+    /// <summary>
+    /// Include the .NET type name when the type of the object being serialized is not the same as its declared type.
+    /// </summary>
+    Auto = 4
   }
 }