Code Coverage Statistics for Source File

Newtonsoft.Json\JsonConvert.cs

Symbol Coverage: 91.89% (204 of 222)

Branch Coverage: 90.09% (100 of 111)

Cyclomatic Complexity Avg: 1.93 Max:20

Code Lines: 226

Symbol Coverage Trend

View:


#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;
using System.IO;
using System.Globalization;
using Newtonsoft.Json.Utilities;
using System.Xml;
using Newtonsoft.Json.Converters;
using System.Text;
#if !NET20 && !SILVERLIGHT
using System.Xml.Linq;
#endif

namespace Newtonsoft.Json
{
  /// <summary>
  /// Provides methods for converting between common language runtime types and JSON types.
  /// </summary>
  public static class JsonConvert
  {
    /// <summary>
    /// Represents JavaScript's boolean value true as a string. This field is read-only.
    /// </summary>
    public static readonly string True = "true";

    /// <summary>
    /// Represents JavaScript's boolean value false as a string. This field is read-only.
    /// </summary>
    public static readonly string False = "false";

    /// <summary>
    /// Represents JavaScript's null as a string. This field is read-only.
    /// </summary>
    public static readonly string Null = "null";

    /// <summary>
    /// Represents JavaScript's undefined as a string. This field is read-only.
    /// </summary>
    public static readonly string Undefined = "undefined";

    /// <summary>
    /// Represents JavaScript's positive infinity as a string. This field is read-only.
    /// </summary>
    public static readonly string PositiveInfinity = "Infinity";

    /// <summary>
    /// Represents JavaScript's negative infinity as a string. This field is read-only.
    /// </summary>
    public static readonly string NegativeInfinity = "-Infinity";

    /// <summary>
    /// Represents JavaScript's NaN as a string. This field is read-only.
    /// </summary>
    public static readonly string NaN = "NaN";

    internal static readonly long InitialJavaScriptDateTicks = 621355968000000000;

    /// <summary>
    /// Converts the <see cref="DateTime"/> to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <returns>A JSON string representation of the <see cref="DateTime"/>.</returns>
    public static string ToString(DateTime value)
    {
      using (StringWriter writer = StringUtils.CreateStringWriter(64))
      {
        WriteDateTimeString(writer, value, GetUtcOffset(value), value.Kind);
        return writer.ToString();
      }
    }

#if !PocketPC && !NET20
    /// <summary>
    /// Converts the <see cref="DateTimeOffset"/> to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <returns>A JSON string representation of the <see cref="DateTimeOffset"/>.</returns>
    public static string ToString(DateTimeOffset value)
    {
      using (StringWriter writer = StringUtils.CreateStringWriter(64))
      {
        WriteDateTimeString(writer, value.UtcDateTime, value.Offset, DateTimeKind.Local);
        return writer.ToString();
      }
    }
#endif

    private static TimeSpan GetUtcOffset(DateTime dateTime)
    {
#if SILVERLIGHT
      return TimeZoneInfo.Local.GetUtcOffset(dateTime);
#else
      return TimeZone.CurrentTimeZone.GetUtcOffset(dateTime);
#endif
    }

    internal static void WriteDateTimeString(TextWriter writer, DateTime value)
    {
      WriteDateTimeString(writer, value, GetUtcOffset(value), value.Kind);
    }

    internal static void WriteDateTimeString(TextWriter writer, DateTime value, TimeSpan offset, DateTimeKind kind)
    {
      long javaScriptTicks = ConvertDateTimeToJavaScriptTicks(value, offset);

      writer.Write(@"""\/Date(");
      writer.Write(javaScriptTicks);
      
      switch (kind)
      {
        case DateTimeKind.Local:
        case DateTimeKind.Unspecified:
          writer.Write((offset.Ticks >= 0L) ? "+" : "-");

          int absHours = Math.Abs(offset.Hours);
          if (absHours < 10)
            writer.Write(0);
          writer.Write(absHours);
          int absMinutes = Math.Abs(offset.Minutes);
          if (absMinutes < 10)
            writer.Write(0);
          writer.Write(absMinutes);
          break;
      }

      writer.Write(@")\/""");
    }

    private static long ToUniversalTicks(DateTime dateTime)
    {
      if (dateTime.Kind == DateTimeKind.Utc)
        return dateTime.Ticks;

      return ToUniversalTicks(dateTime, GetUtcOffset(dateTime));
    }

    private static long ToUniversalTicks(DateTime dateTime, TimeSpan offset)
    {
      if (dateTime.Kind == DateTimeKind.Utc)
        return dateTime.Ticks;

      long ticks = dateTime.Ticks - offset.Ticks;
      if (ticks > 3155378975999999999L)
        return 3155378975999999999L;

      if (ticks < 0L)
        return 0L;

      return ticks;
    }

    internal static long ConvertDateTimeToJavaScriptTicks(DateTime dateTime, TimeSpan offset)
    {
      long universialTicks = ToUniversalTicks(dateTime, offset);

      return UniversialTicksToJavaScriptTicks(universialTicks);
    }

    internal static long ConvertDateTimeToJavaScriptTicks(DateTime dateTime)
    {
      long universialTicks = ToUniversalTicks(dateTime);

      return UniversialTicksToJavaScriptTicks(universialTicks);
    }

    private static long UniversialTicksToJavaScriptTicks(long universialTicks)
    {
      long javaScriptTicks = (universialTicks - InitialJavaScriptDateTicks) / 10000;

      return javaScriptTicks;
    }

    internal static DateTime ConvertJavaScriptTicksToDateTime(long javaScriptTicks)
    {
      DateTime dateTime = new DateTime((javaScriptTicks * 10000) + InitialJavaScriptDateTicks, DateTimeKind.Utc);

      return dateTime;
    }

    /// <summary>
    /// Converts the <see cref="Boolean"/> to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <returns>A JSON string representation of the <see cref="Boolean"/>.</returns>
    public static string ToString(bool value)
    {
      return (value) ? True : False;
    }

    /// <summary>
    /// Converts the <see cref="Char"/> to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <returns>A JSON string representation of the <see cref="Char"/>.</returns>
    public static string ToString(char value)
    {
      return ToString(char.ToString(value));
    }

    /// <summary>
    /// Converts the <see cref="Enum"/> to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <returns>A JSON string representation of the <see cref="Enum"/>.</returns>
    public static string ToString(Enum value)
    {
      return value.ToString("D");
    }

    /// <summary>
    /// Converts the <see cref="Int32"/> to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <returns>A JSON string representation of the <see cref="Int32"/>.</returns>
    public static string ToString(int value)
    {
      return value.ToString(null, CultureInfo.InvariantCulture);
    }

    /// <summary>
    /// Converts the <see cref="Int16"/> to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <returns>A JSON string representation of the <see cref="Int16"/>.</returns>
    public static string ToString(short value)
    {
      return value.ToString(null, CultureInfo.InvariantCulture);
    }

    /// <summary>
    /// Converts the <see cref="UInt16"/> to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <returns>A JSON string representation of the <see cref="UInt16"/>.</returns>
    public static string ToString(ushort value)
    {
      return value.ToString(null, CultureInfo.InvariantCulture);
    }

    /// <summary>
    /// Converts the <see cref="UInt32"/> to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <returns>A JSON string representation of the <see cref="UInt32"/>.</returns>
    public static string ToString(uint value)
    {
      return value.ToString(null, CultureInfo.InvariantCulture);
    }

    /// <summary>
    /// Converts the <see cref="Int64"/>  to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <returns>A JSON string representation of the <see cref="Int64"/>.</returns>
    public static string ToString(long value)
    {
      return value.ToString(null, CultureInfo.InvariantCulture);
    }

    /// <summary>
    /// Converts the <see cref="UInt64"/> to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <returns>A JSON string representation of the <see cref="UInt64"/>.</returns>
    public static string ToString(ulong value)
    {
      return value.ToString(null, CultureInfo.InvariantCulture);
    }

    /// <summary>
    /// Converts the <see cref="Single"/> to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <returns>A JSON string representation of the <see cref="Single"/>.</returns>
    public static string ToString(float value)
    {
      return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture));
    }

    /// <summary>
    /// Converts the <see cref="Double"/> to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <returns>A JSON string representation of the <see cref="Double"/>.</returns>
    public static string ToString(double value)
    {
      return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture));
    }

    private static string EnsureDecimalPlace(double value, string text)
    {
      if (double.IsNaN(value) || double.IsInfinity(value) || text.IndexOf('.') != -1 || text.IndexOf('E') != -1)
        return text;

      return text + ".0";
    }

    private static string EnsureDecimalPlace(string text)
    {
      if (text.IndexOf('.') != -1)
        return text;

      return text + ".0";
    }

    /// <summary>
    /// Converts the <see cref="Byte"/> to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <returns>A JSON string representation of the <see cref="Byte"/>.</returns>
    public static string ToString(byte value)
    {
      return value.ToString(null, CultureInfo.InvariantCulture);
    }

    /// <summary>
    /// Converts the <see cref="SByte"/> to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <returns>A JSON string representation of the <see cref="SByte"/>.</returns>
    public static string ToString(sbyte value)
    {
      return value.ToString(null, CultureInfo.InvariantCulture);
    }

    /// <summary>
    /// Converts the <see cref="Decimal"/> to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <returns>A JSON string representation of the <see cref="SByte"/>.</returns>
    public static string ToString(decimal value)
    {
      return EnsureDecimalPlace(value.ToString(null, CultureInfo.InvariantCulture));
    }

    /// <summary>
    /// Converts the <see cref="Guid"/> to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <returns>A JSON string representation of the <see cref="Guid"/>.</returns>
    public static string ToString(Guid value)
    {
      return '"' + value.ToString("D", CultureInfo.InvariantCulture) + '"';
    }

    /// <summary>
    /// Converts the <see cref="String"/> to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <returns>A JSON string representation of the <see cref="String"/>.</returns>
    public static string ToString(string value)
    {
      return ToString(value, '"');
    }

    /// <summary>
    /// Converts the <see cref="String"/> to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <param name="delimter">The string delimiter character.</param>
    /// <returns>A JSON string representation of the <see cref="String"/>.</returns>
    public static string ToString(string value, char delimter)
    {
      return JavaScriptUtils.ToEscapedJavaScriptString(value, delimter, true);
    }

    /// <summary>
    /// Converts the <see cref="Object"/> to its JSON string representation.
    /// </summary>
    /// <param name="value">The value to convert.</param>
    /// <returns>A JSON string representation of the <see cref="Object"/>.</returns>
    public static string ToString(object value)
    {
      if (value == null)
        return Null;

      IConvertible convertible = value as IConvertible;

      if (convertible != null)
      {
        switch (convertible.GetTypeCode())
        {
          case TypeCode.String:
            return ToString(convertible.ToString(CultureInfo.InvariantCulture));
          case TypeCode.Char:
            return ToString(convertible.ToChar(CultureInfo.InvariantCulture));
          case TypeCode.Boolean:
            return ToString(convertible.ToBoolean(CultureInfo.InvariantCulture));
          case TypeCode.SByte:
            return ToString(convertible.ToSByte(CultureInfo.InvariantCulture));
          case TypeCode.Int16:
            return ToString(convertible.ToInt16(CultureInfo.InvariantCulture));
          case TypeCode.UInt16:
            return ToString(convertible.ToUInt16(CultureInfo.InvariantCulture));
          case TypeCode.Int32:
            return ToString(convertible.ToInt32(CultureInfo.InvariantCulture));
          case TypeCode.Byte:
            return ToString(convertible.ToByte(CultureInfo.InvariantCulture));
          case TypeCode.UInt32:
            return ToString(convertible.ToUInt32(CultureInfo.InvariantCulture));
          case TypeCode.Int64:
            return ToString(convertible.ToInt64(CultureInfo.InvariantCulture));
          case TypeCode.UInt64:
            return ToString(convertible.ToUInt64(CultureInfo.InvariantCulture));
          case TypeCode.Single:
            return ToString(convertible.ToSingle(CultureInfo.InvariantCulture));
          case TypeCode.Double:
            return ToString(convertible.ToDouble(CultureInfo.InvariantCulture));
          case TypeCode.DateTime:
            return ToString(convertible.ToDateTime(CultureInfo.InvariantCulture));
          case TypeCode.Decimal:
            return ToString(convertible.ToDecimal(CultureInfo.InvariantCulture));
          case TypeCode.DBNull:
            return Null;
        }
      }
#if !PocketPC && !NET20
      else if (value is DateTimeOffset)
      {
        return ToString((DateTimeOffset)value);
      }
#endif

      throw new ArgumentException("Unsupported type: {0}. Use the JsonSerializer class to get the object's JSON representation.".FormatWith(CultureInfo.InvariantCulture, value.GetType()));
    }

    private static bool IsJsonPrimitiveTypeCode(TypeCode typeCode)
    {
      switch (typeCode)
      {
        case TypeCode.String:
        case TypeCode.Char:
        case TypeCode.Boolean:
        case TypeCode.SByte:
        case TypeCode.Int16:
        case TypeCode.UInt16:
        case TypeCode.Int32:
        case TypeCode.Byte:
        case TypeCode.UInt32:
        case TypeCode.Int64:
        case TypeCode.UInt64:
        case TypeCode.Single:
        case TypeCode.Double:
        case TypeCode.DateTime:
        case TypeCode.Decimal:
        case TypeCode.DBNull:
          return true;
        default:
          return false;
      }
    }

    internal static bool IsJsonPrimitiveType(Type type)
    {
      if (ReflectionUtils.IsNullableType(type))
        type = Nullable.GetUnderlyingType(type);

#if !PocketPC && !NET20
     if (type == typeof(DateTimeOffset))
        return true;
#endif
      if (type == typeof(byte[]))
        return true;

      return IsJsonPrimitiveTypeCode(Type.GetTypeCode(type));
    }

    internal static bool IsJsonPrimitive(object value)
    {
      if (value == null)
        return true;

      IConvertible convertible = value as IConvertible;

      if (convertible != null)
        return IsJsonPrimitiveTypeCode(convertible.GetTypeCode());

#if !PocketPC && !NET20
      if (value is DateTimeOffset)
        return true;
#endif

      if (value is byte[])
        return true;

      return false;
    }

    /// <summary>
    /// Serializes the specified object to a JSON string.
    /// </summary>
    /// <param name="value">The object to serialize.</param>
    /// <returns>A JSON string representation of the object.</returns>
    public static string SerializeObject(object value)
    {
      return SerializeObject(value, Formatting.None, (JsonSerializerSettings)null);
    }

    /// <summary>
    /// Serializes the specified object to a JSON string.
    /// </summary>
    /// <param name="value">The object to serialize.</param>
    /// <param name="formatting">Indicates how the output is formatted.</param>
    /// <returns>
    /// A JSON string representation of the object.
    /// </returns>
    public static string SerializeObject(object value, Formatting formatting)
    {
      return SerializeObject(value, formatting, (JsonSerializerSettings)null);
    }

    /// <summary>
    /// Serializes the specified object to a JSON string using a collection of <see cref="JsonConverter"/>.
    /// </summary>
    /// <param name="value">The object to serialize.</param>
    /// <param name="converters">A collection converters used while serializing.</param>
    /// <returns>A JSON string representation of the object.</returns>
    public static string SerializeObject(object value, params JsonConverter[] converters)
    {
      return SerializeObject(value, Formatting.None, converters);
    }

    /// <summary>
    /// Serializes the specified object to a JSON string using a collection of <see cref="JsonConverter"/>.
    /// </summary>
    /// <param name="value">The object to serialize.</param>
    /// <param name="formatting">Indicates how the output is formatted.</param>
    /// <param name="converters">A collection converters used while serializing.</param>
    /// <returns>A JSON string representation of the object.</returns>
    public static string SerializeObject(object value, Formatting formatting, params JsonConverter[] converters)
    {
      JsonSerializerSettings settings = (converters != null && converters.Length > 0)
        ? new JsonSerializerSettings { Converters = converters }
        : null;

      return SerializeObject(value, formatting, settings);
    }

    /// <summary>
    /// Serializes the specified object to a JSON string using a collection of <see cref="JsonConverter"/>.
    /// </summary>
    /// <param name="value">The object to serialize.</param>
    /// <param name="formatting">Indicates how the output is formatted.</param>
    /// <param name="settings">The <see cref="JsonSerializerSettings"/> used to serialize the object.
    /// If this is null, default serialization settings will be is used.</param>
    /// <returns>
    /// A JSON string representation of the object.
    /// </returns>
    public static string SerializeObject(object value, Formatting formatting, JsonSerializerSettings settings)
    {
      JsonSerializer jsonSerializer = JsonSerializer.Create(settings);

      StringBuilder sb = new StringBuilder(128);
      StringWriter sw = new StringWriter(sb, CultureInfo.InvariantCulture);
      using (JsonTextWriter jsonWriter = new JsonTextWriter(sw))
      {
        jsonWriter.Formatting = formatting;

        jsonSerializer.Serialize(jsonWriter, value);
      }

      return sw.ToString();
    }

    /// <summary>
    /// Deserializes the specified object to a Json object.
    /// </summary>
    /// <param name="value">The object to deserialize.</param>
    /// <returns>The deserialized object from the Json string.</returns>
    public static object DeserializeObject(string value)
    {
      return DeserializeObject(value, null, (JsonSerializerSettings)null);
    }

    /// <summary>
    /// Deserializes the specified object to a Json object.
    /// </summary>
    /// <param name="value">The object to deserialize.</param>
    /// <param name="type">The <see cref="Type"/> of object being deserialized.</param>
    /// <returns>The deserialized object from the Json string.</returns>
    public static object DeserializeObject(string value, Type type)
    {
      return DeserializeObject(value, type, (JsonSerializerSettings)null);
    }

    /// <summary>
    /// Deserializes the specified object to a Json object.
    /// </summary>
    /// <typeparam name="T">The type of the object to deserialize.</typeparam>
    /// <param name="value">The object to deserialize.</param>
    /// <returns>The deserialized object from the Json string.</returns>
    public static T DeserializeObject<T>(string value)
    {
      return DeserializeObject<T>(value, (JsonSerializerSettings)null);
    }

    /// <summary>
    /// Deserializes the specified JSON to the given anonymous type.
    /// </summary>
    /// <typeparam name="T">
    /// The anonymous type to deserialize to. This can't be specified
    /// traditionally and must be infered from the anonymous type passed
    /// as a parameter.
    /// </typeparam>
    /// <param name="value">The object to deserialize.</param>
    /// <param name="anonymousTypeObject">The anonymous type object.</param>
    /// <returns>The deserialized anonymous type from the JSON string.</returns>
    public static T DeserializeAnonymousType<T>(string value, T anonymousTypeObject)
    {
      return DeserializeObject<T>(value);
    }

    /// <summary>
    /// Deserializes the JSON string to the specified type.
    /// </summary>
    /// <typeparam name="T">The type of the object to deserialize.</typeparam>
    /// <param name="value">The object to deserialize.</param>
    /// <param name="converters">Converters to use while deserializing.</param>
    /// <returns>The deserialized object from the JSON string.</returns>
    public static T DeserializeObject<T>(string value, params JsonConverter[] converters)
    {
      return (T)DeserializeObject(value, typeof(T), converters);
    }

    /// <summary>
    /// Deserializes the JSON string to the specified type.
    /// </summary>
    /// <typeparam name="T">The type of the object to deserialize.</typeparam>
    /// <param name="value">The object to deserialize.</param>
    /// <param name="settings">
    /// The <see cref="JsonSerializerSettings"/> used to deserialize the object.
    /// If this is null, default serialization settings will be is used.
    /// </param>
    /// <returns>The deserialized object from the JSON string.</returns>
    public static T DeserializeObject<T>(string value, JsonSerializerSettings settings)
    {
      return (T)DeserializeObject(value, typeof(T), settings);
    }

    /// <summary>
    /// Deserializes the JSON string to the specified type.
    /// </summary>
    /// <param name="value">The object to deserialize.</param>
    /// <param name="type">The type of the object to deserialize.</param>
    /// <param name="converters">Converters to use while deserializing.</param>
    /// <returns>The deserialized object from the JSON string.</returns>
    public static object DeserializeObject(string value, Type type, params JsonConverter[] converters)
    {
      JsonSerializerSettings settings = (converters != null && converters.Length > 0)
        ? new JsonSerializerSettings { Converters = converters }
        : null;

      return DeserializeObject(value, type, settings);
    }

    /// <summary>
    /// Deserializes the JSON string to the specified type.
    /// </summary>
    /// <param name="value">The JSON to deserialize.</param>
    /// <param name="type">The type of the object to deserialize.</param>
    /// <param name="settings">
    /// The <see cref="JsonSerializerSettings"/> used to deserialize the object.
    /// If this is null, default serialization settings will be is used.
    /// </param>
    /// <returns>The deserialized object from the JSON string.</returns>
    public static object DeserializeObject(string value, Type type, JsonSerializerSettings settings)
    {
      StringReader sr = new StringReader(value);
      JsonSerializer jsonSerializer = JsonSerializer.Create(settings);

      object deserializedValue;

      using (JsonReader jsonReader = new JsonTextReader(sr))
      {
        deserializedValue = jsonSerializer.Deserialize(jsonReader, type);

        if (jsonReader.Read() && jsonReader.TokenType != JsonToken.Comment)
          throw new JsonSerializationException("Additional text found in JSON string after finishing deserializing object.");
      }

      return deserializedValue;
    }

    /// <summary>
    /// Populates the object with values from the JSON string.
    /// </summary>
    /// <param name="value">The JSON to populate values from.</param>
    /// <param name="target">The target object to populate values onto.</param>
    public static void PopulateObject(string value, object target)
    {
      PopulateObject(value, target, null);
    }


    /// <summary>
    /// Populates the object with values from the JSON string.
    /// </summary>
    /// <param name="value">The JSON to populate values from.</param>
    /// <param name="target">The target object to populate values onto.</param>
    /// <param name="settings">
    /// The <see cref="JsonSerializerSettings"/> used to deserialize the object.
    /// If this is null, default serialization settings will be is used.
    /// </param>
    public static void PopulateObject(string value, object target, JsonSerializerSettings settings)
    {
      StringReader sr = new StringReader(value);
      JsonSerializer jsonSerializer = JsonSerializer.Create(settings);

      using (JsonReader jsonReader = new JsonTextReader(sr))
      {
        jsonSerializer.Populate(jsonReader, target);

        if (jsonReader.Read() && jsonReader.TokenType != JsonToken.Comment)
          throw new JsonSerializationException("Additional text found in JSON string after finishing deserializing object.");
      }
    }

#if !NET20 && !SILVERLIGHT
    /// <summary>
    /// Serializes the <see cref="XNode"/> to a JSON string.
    /// </summary>
    /// <param name="node">The node to convert to JSON.</param>
    /// <returns>A JSON string of the XNode.</returns>
    public static string SerializeXNode(XObject node)
    {
      return SerializeXNode(node, Formatting.None);
    }

    /// <summary>
    /// Serializes the <see cref="XNode"/> to a JSON string.
    /// </summary>
    /// <param name="node">The node to convert to JSON.</param>
    /// <param name="formatting">Indicates how the output is formatted.</param>
    /// <returns>A JSON string of the XNode.</returns>
    public static string SerializeXNode(XObject node, Formatting formatting)
    {
      XmlNodeConverter converter = new XmlNodeConverter();

      return SerializeObject(node, formatting, converter);
    }

    /// <summary>
    /// Deserializes the <see cref="XNode"/> from a JSON string.
    /// </summary>
    /// <param name="value">The JSON string.</param>
    /// <returns>The deserialized XNode</returns>
    public static XDocument DeserializeXNode(string value)
    {
      return DeserializeXNode(value, null);
    }

    /// <summary>
    /// Deserializes the <see cref="XNode"/> from a JSON string nested in a root elment.
    /// </summary>
    /// <param name="value">The JSON string.</param>
    /// <param name="deserializeRootElementName">The name of the root element to append when deserializing.</param>
    /// <returns>The deserialized XNode</returns>
    public static XDocument DeserializeXNode(string value, string deserializeRootElementName)
    {
      XmlNodeConverter converter = new XmlNodeConverter();
      converter.DeserializeRootElementName = deserializeRootElementName;

      return (XDocument)DeserializeObject(value, typeof(XDocument), converter);
    }
#endif

#if !SILVERLIGHT
    /// <summary>
    /// Serializes the XML node to a JSON string.
    /// </summary>
    /// <param name="node">The node to serialize.</param>
    /// <returns>A JSON string of the XmlNode.</returns>
    public static string SerializeXmlNode(XmlNode node)
    {
      return SerializeXmlNode(node, Formatting.None);
    }

    /// <summary>
    /// Serializes the XML node to a JSON string.
    /// </summary>
    /// <param name="node">The node to serialize.</param>
    /// <param name="formatting">Indicates how the output is formatted.</param>
    /// <returns>A JSON string of the XmlNode.</returns>
    public static string SerializeXmlNode(XmlNode node, Formatting formatting)
    {
      XmlNodeConverter converter = new XmlNodeConverter();

      return SerializeObject(node, formatting, converter);
    }

    /// <summary>
    /// Deserializes the XmlNode from a JSON string.
    /// </summary>
    /// <param name="value">The JSON string.</param>
    /// <returns>The deserialized XmlNode</returns>
    public static XmlDocument DeserializeXmlNode(string value)
    {
      return DeserializeXmlNode(value, null);
    }

    /// <summary>
    /// Deserializes the XmlNode from a JSON string nested in a root elment.
    /// </summary>
    /// <param name="value">The JSON string.</param>
    /// <param name="deserializeRootElementName">The name of the root element to append when deserializing.</param>
    /// <returns>The deserialized XmlNode</returns>
    public static XmlDocument DeserializeXmlNode(string value, string deserializeRootElementName)
    {
      XmlNodeConverter converter = new XmlNodeConverter();
      converter.DeserializeRootElementName = deserializeRootElementName;

      return (XmlDocument)DeserializeObject(value, typeof(XmlDocument), converter);
    }
#endif
  }
}

L	V	Source
1		#region License
2		// Copyright (c) 2007 James Newton-King
3		//
4		// Permission is hereby granted, free of charge, to any person
5		// obtaining a copy of this software and associated documentation
6		// files (the "Software"), to deal in the Software without
7		// restriction, including without limitation the rights to use,
8		// copy, modify, merge, publish, distribute, sublicense, and/or sell
9		// copies of the Software, and to permit persons to whom the
10		// Software is furnished to do so, subject to the following
11		// conditions:
12		//
13		// The above copyright notice and this permission notice shall be
14		// included in all copies or substantial portions of the Software.
15		//
16		// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17		// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
18		// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19		// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
20		// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21		// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22		// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23		// OTHER DEALINGS IN THE SOFTWARE.
24		#endregion
25
26		using System;
27		using System.IO;
28		using System.Globalization;
29		using Newtonsoft.Json.Utilities;
30		using System.Xml;
31		using Newtonsoft.Json.Converters;
32		using System.Text;
33		#if !NET20 && !SILVERLIGHT
34		using System.Xml.Linq;
35		#endif
36
37		namespace Newtonsoft.Json
38		{
39		/// <summary>
40		/// Provides methods for converting between common language runtime types and JSON types.
41		/// </summary>
42		public static class JsonConvert
43		{
44		/// <summary>
45		/// Represents JavaScript's boolean value true as a string. This field is read-only.
46		/// </summary>
47	1	public static readonly string True = "true";
48
49		/// <summary>
50		/// Represents JavaScript's boolean value false as a string. This field is read-only.
51		/// </summary>
52	1	public static readonly string False = "false";
53
54		/// <summary>
55		/// Represents JavaScript's null as a string. This field is read-only.
56		/// </summary>
57	1	public static readonly string Null = "null";
58
59		/// <summary>
60		/// Represents JavaScript's undefined as a string. This field is read-only.
61		/// </summary>
62	1	public static readonly string Undefined = "undefined";
63
64		/// <summary>
65		/// Represents JavaScript's positive infinity as a string. This field is read-only.
66		/// </summary>
67	1	public static readonly string PositiveInfinity = "Infinity";
68
69		/// <summary>
70		/// Represents JavaScript's negative infinity as a string. This field is read-only.
71		/// </summary>
72	1	public static readonly string NegativeInfinity = "-Infinity";
73
74		/// <summary>
75		/// Represents JavaScript's NaN as a string. This field is read-only.
76		/// </summary>
77	1	public static readonly string NaN = "NaN";
78
79	1	internal static readonly long InitialJavaScriptDateTicks = 621355968000000000;
80
81		/// <summary>
82		/// Converts the <see cref="DateTime"/> to its JSON string representation.
83		/// </summary>
84		/// <param name="value">The value to convert.</param>
85		/// <returns>A JSON string representation of the <see cref="DateTime"/>.</returns>
86		public static string ToString(DateTime value)
87		{
88	1	using (StringWriter writer = StringUtils.CreateStringWriter(64))
89		{
90	1	WriteDateTimeString(writer, value, GetUtcOffset(value), value.Kind);
91	1	return writer.ToString();
92		}
93	1	}
94
95		#if !PocketPC && !NET20
96		/// <summary>
97		/// Converts the <see cref="DateTimeOffset"/> to its JSON string representation.
98		/// </summary>
99		/// <param name="value">The value to convert.</param>
100		/// <returns>A JSON string representation of the <see cref="DateTimeOffset"/>.</returns>
101		public static string ToString(DateTimeOffset value)
102		{
103	7	using (StringWriter writer = StringUtils.CreateStringWriter(64))
104		{
105	7	WriteDateTimeString(writer, value.UtcDateTime, value.Offset, DateTimeKind.Local);
106	7	return writer.ToString();
107		}
108	7	}
109		#endif
110
111		private static TimeSpan GetUtcOffset(DateTime dateTime)
112		{
113		#if SILVERLIGHT
114		return TimeZoneInfo.Local.GetUtcOffset(dateTime);
115		#else
116	20874	return TimeZone.CurrentTimeZone.GetUtcOffset(dateTime);
117		#endif
118	20874	}
119
120		internal static void WriteDateTimeString(TextWriter writer, DateTime value)
121		{
122	20873	WriteDateTimeString(writer, value, GetUtcOffset(value), value.Kind);
123	20873	}
124
125		internal static void WriteDateTimeString(TextWriter writer, DateTime value, TimeSpan offset, DateTimeKind kind)
126		{
127	20881	long javaScriptTicks = ConvertDateTimeToJavaScriptTicks(value, offset);
128
129	20881	writer.Write(@"""\/Date(");
130	20881	writer.Write(javaScriptTicks);
131
132	20881	switch (kind)
133		{
134		case DateTimeKind.Local:
135		case DateTimeKind.Unspecified:
136	20826	writer.Write((offset.Ticks >= 0L) ? "+" : "-");
137
138	20826	int absHours = Math.Abs(offset.Hours);
139	20826	if (absHours < 10)
140	20825	writer.Write(0);
141	20826	writer.Write(absHours);
142	20826	int absMinutes = Math.Abs(offset.Minutes);
143	20826	if (absMinutes < 10)
144	20825	writer.Write(0);
145	20826	writer.Write(absMinutes);
146	20826	break;
147		}
148
149	20881	writer.Write(@")\/""");
150	20881	}
151
152		private static long ToUniversalTicks(DateTime dateTime)
153		{
154	20825	if (dateTime.Kind == DateTimeKind.Utc)
155	20825	return dateTime.Ticks;
156
157	0	return ToUniversalTicks(dateTime, GetUtcOffset(dateTime));
158	20825	}
159
160		private static long ToUniversalTicks(DateTime dateTime, TimeSpan offset)
161		{
162	20882	if (dateTime.Kind == DateTimeKind.Utc)
163	63	return dateTime.Ticks;
164
165	20819	long ticks = dateTime.Ticks - offset.Ticks;
166	20819	if (ticks > 3155378975999999999L)
167	0	return 3155378975999999999L;
168
169	20819	if (ticks < 0L)
170	0	return 0L;
171
172	20819	return ticks;
173	20882	}
174
175		internal static long ConvertDateTimeToJavaScriptTicks(DateTime dateTime, TimeSpan offset)
176		{
177	20882	long universialTicks = ToUniversalTicks(dateTime, offset);
178
179	20882	return UniversialTicksToJavaScriptTicks(universialTicks);
180	20882	}
181
182		internal static long ConvertDateTimeToJavaScriptTicks(DateTime dateTime)
183		{
184	20825	long universialTicks = ToUniversalTicks(dateTime);
185
186	20825	return UniversialTicksToJavaScriptTicks(universialTicks);
187	20825	}
188
189		private static long UniversialTicksToJavaScriptTicks(long universialTicks)
190		{
191	41707	long javaScriptTicks = (universialTicks - InitialJavaScriptDateTicks) / 10000;
192
193	41707	return javaScriptTicks;
194	41707	}
195
196		internal static DateTime ConvertJavaScriptTicksToDateTime(long javaScriptTicks)
197		{
198	40076	DateTime dateTime = new DateTime((javaScriptTicks * 10000) + InitialJavaScriptDateTicks, DateTimeKind.Utc);
199
200	40076	return dateTime;
201	40076	}
202
203		/// <summary>
204		/// Converts the <see cref="Boolean"/> to its JSON string representation.
205		/// </summary>
206		/// <param name="value">The value to convert.</param>
207		/// <returns>A JSON string representation of the <see cref="Boolean"/>.</returns>
208		public static string ToString(bool value)
209		{
210	38	return (value) ? True : False;
211	38	}
212
213		/// <summary>
214		/// Converts the <see cref="Char"/> to its JSON string representation.
215		/// </summary>
216		/// <param name="value">The value to convert.</param>
217		/// <returns>A JSON string representation of the <see cref="Char"/>.</returns>
218		public static string ToString(char value)
219		{
220	10	return ToString(char.ToString(value));
221	10	}
222
223		/// <summary>
224		/// Converts the <see cref="Enum"/> to its JSON string representation.
225		/// </summary>
226		/// <param name="value">The value to convert.</param>
227		/// <returns>A JSON string representation of the <see cref="Enum"/>.</returns>
228		public static string ToString(Enum value)
229		{
230	1	return value.ToString("D");
231	1	}
232
233		/// <summary>
234		/// Converts the <see cref="Int32"/> to its JSON string representation.
235		/// </summary>
236		/// <param name="value">The value to convert.</param>
237		/// <returns>A JSON string representation of the <see cref="Int32"/>.</returns>
238		public static string ToString(int value)
239		{
240	15779	return value.ToString(null, CultureInfo.InvariantCulture);
241	15779	}
242
243		/// <summary>
244		/// Converts the <see cref="Int16"/> to its JSON string representation.
245		/// </summary>
246		/// <param name="value">The value to convert.</param>
247		/// <returns>A JSON string representation of the <see cref="Int16"/>.</returns>
248		public static string ToString(short value)
249		{
250	6	return value.ToString(null, CultureInfo.InvariantCulture);
251	6	}
252
253		/// <summary>
254		/// Converts the <see cref="UInt16"/> to its JSON string representation.
255		/// </summary>
256		/// <param name="value">The value to convert.</param>
257		/// <returns>A JSON string representation of the <see cref="UInt16"/>.</returns>
258		public static string ToString(ushort value)
259		{
260	4	return value.ToString(null, CultureInfo.InvariantCulture);
261	4	}
262
263		/// <summary>
264		/// Converts the <see cref="UInt32"/> to its JSON string representation.
265		/// </summary>
266		/// <param name="value">The value to convert.</param>
267		/// <returns>A JSON string representation of the <see cref="UInt32"/>.</returns>
268		public static string ToString(uint value)
269		{
270	4	return value.ToString(null, CultureInfo.InvariantCulture);
271	4	}
272
273		/// <summary>
274		/// Converts the <see cref="Int64"/> to its JSON string representation.
275		/// </summary>
276		/// <param name="value">The value to convert.</param>
277		/// <returns>A JSON string representation of the <see cref="Int64"/>.</returns>
278		public static string ToString(long value)
279		{
280	61	return value.ToString(null, CultureInfo.InvariantCulture);
281	61	}
282
283		/// <summary>
284		/// Converts the <see cref="UInt64"/> to its JSON string representation.
285		/// </summary>
286		/// <param name="value">The value to convert.</param>
287		/// <returns>A JSON string representation of the <see cref="UInt64"/>.</returns>
288		public static string ToString(ulong value)
289		{
290	4	return value.ToString(null, CultureInfo.InvariantCulture);
291	4	}
292
293		/// <summary>
294		/// Converts the <see cref="Single"/> to its JSON string representation.
295		/// </summary>
296		/// <param name="value">The value to convert.</param>
297		/// <returns>A JSON string representation of the <see cref="Single"/>.</returns>
298		public static string ToString(float value)
299		{
300	12	return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture));
301	12	}
302
303		/// <summary>
304		/// Converts the <see cref="Double"/> to its JSON string representation.
305		/// </summary>
306		/// <param name="value">The value to convert.</param>
307		/// <returns>A JSON string representation of the <see cref="Double"/>.</returns>
308		public static string ToString(double value)
309		{
310	53	return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture));
311	53	}
312
313		private static string EnsureDecimalPlace(double value, string text)
314		{
315	65	if (double.IsNaN(value) \|\| double.IsInfinity(value) \|\| text.IndexOf('.') != -1 \|\| text.IndexOf('E') != -1)
316	53	return text;
317
318	12	return text + ".0";
319	65	}
320
321		private static string EnsureDecimalPlace(string text)
322		{
323	5260	if (text.IndexOf('.') != -1)
324	5237	return text;
325
326	23	return text + ".0";
327	5260	}
328
329		/// <summary>
330		/// Converts the <see cref="Byte"/> to its JSON string representation.
331		/// </summary>
332		/// <param name="value">The value to convert.</param>
333		/// <returns>A JSON string representation of the <see cref="Byte"/>.</returns>
334		public static string ToString(byte value)
335		{
336	5	return value.ToString(null, CultureInfo.InvariantCulture);
337	5	}
338
339		/// <summary>
340		/// Converts the <see cref="SByte"/> to its JSON string representation.
341		/// </summary>
342		/// <param name="value">The value to convert.</param>
343		/// <returns>A JSON string representation of the <see cref="SByte"/>.</returns>
344		public static string ToString(sbyte value)
345		{
346	4	return value.ToString(null, CultureInfo.InvariantCulture);
347	4	}
348
349		/// <summary>
350		/// Converts the <see cref="Decimal"/> to its JSON string representation.
351		/// </summary>
352		/// <param name="value">The value to convert.</param>
353		/// <returns>A JSON string representation of the <see cref="SByte"/>.</returns>
354		public static string ToString(decimal value)
355		{
356	5260	return EnsureDecimalPlace(value.ToString(null, CultureInfo.InvariantCulture));
357	5260	}
358
359		/// <summary>
360		/// Converts the <see cref="Guid"/> to its JSON string representation.
361		/// </summary>
362		/// <param name="value">The value to convert.</param>
363		/// <returns>A JSON string representation of the <see cref="Guid"/>.</returns>
364		public static string ToString(Guid value)
365		{
366	1	return '"' + value.ToString("D", CultureInfo.InvariantCulture) + '"';
367	1	}
368
369		/// <summary>
370		/// Converts the <see cref="String"/> to its JSON string representation.
371		/// </summary>
372		/// <param name="value">The value to convert.</param>
373		/// <returns>A JSON string representation of the <see cref="String"/>.</returns>
374		public static string ToString(string value)
375		{
376	12	return ToString(value, '"');
377	12	}
378
379		/// <summary>
380		/// Converts the <see cref="String"/> to its JSON string representation.
381		/// </summary>
382		/// <param name="value">The value to convert.</param>
383		/// <param name="delimter">The string delimiter character.</param>
384		/// <returns>A JSON string representation of the <see cref="String"/>.</returns>
385		public static string ToString(string value, char delimter)
386		{
387	12	return JavaScriptUtils.ToEscapedJavaScriptString(value, delimter, true);
388	12	}
389
390		/// <summary>
391		/// Converts the <see cref="Object"/> to its JSON string representation.
392		/// </summary>
393		/// <param name="value">The value to convert.</param>
394		/// <returns>A JSON string representation of the <see cref="Object"/>.</returns>
395		public static string ToString(object value)
396		{
397	19	if (value == null)
398	1	return Null;
399
400	18	IConvertible convertible = value as IConvertible;
401
402	18	if (convertible != null)
403		{
404	16	switch (convertible.GetTypeCode())
405		{
406		case TypeCode.String:
407	1	return ToString(convertible.ToString(CultureInfo.InvariantCulture));
408		case TypeCode.Char:
409	1	return ToString(convertible.ToChar(CultureInfo.InvariantCulture));
410		case TypeCode.Boolean:
411	1	return ToString(convertible.ToBoolean(CultureInfo.InvariantCulture));
412		case TypeCode.SByte:
413	1	return ToString(convertible.ToSByte(CultureInfo.InvariantCulture));
414		case TypeCode.Int16:
415	1	return ToString(convertible.ToInt16(CultureInfo.InvariantCulture));
416		case TypeCode.UInt16:
417	1	return ToString(convertible.ToUInt16(CultureInfo.InvariantCulture));
418		case TypeCode.Int32:
419	1	return ToString(convertible.ToInt32(CultureInfo.InvariantCulture));
420		case TypeCode.Byte:
421	1	return ToString(convertible.ToByte(CultureInfo.InvariantCulture));
422		case TypeCode.UInt32:
423	1	return ToString(convertible.ToUInt32(CultureInfo.InvariantCulture));
424		case TypeCode.Int64:
425	1	return ToString(convertible.ToInt64(CultureInfo.InvariantCulture));
426		case TypeCode.UInt64:
427	1	return ToString(convertible.ToUInt64(CultureInfo.InvariantCulture));
428		case TypeCode.Single:
429	1	return ToString(convertible.ToSingle(CultureInfo.InvariantCulture));
430		case TypeCode.Double:
431	1	return ToString(convertible.ToDouble(CultureInfo.InvariantCulture));
432		case TypeCode.DateTime:
433	1	return ToString(convertible.ToDateTime(CultureInfo.InvariantCulture));
434		case TypeCode.Decimal:
435	1	return ToString(convertible.ToDecimal(CultureInfo.InvariantCulture));
436		case TypeCode.DBNull:
437	1	return Null;
438		}
439		}
440		#if !PocketPC && !NET20
441	2	else if (value is DateTimeOffset)
442		{
443	1	return ToString((DateTimeOffset)value);
444		}
445		#endif
446
447	1	throw new ArgumentException("Unsupported type: {0}. Use the JsonSerializer class to get the object's JSON representation.".FormatWith(CultureInfo.InvariantCulture, value.GetType()));
448	18	}
449
450		private static bool IsJsonPrimitiveTypeCode(TypeCode typeCode)
451		{
452	306	switch (typeCode)
453		{
454		case TypeCode.String:
455		case TypeCode.Char:
456		case TypeCode.Boolean:
457		case TypeCode.SByte:
458		case TypeCode.Int16:
459		case TypeCode.UInt16:
460		case TypeCode.Int32:
461		case TypeCode.Byte:
462		case TypeCode.UInt32:
463		case TypeCode.Int64:
464		case TypeCode.UInt64:
465		case TypeCode.Single:
466		case TypeCode.Double:
467		case TypeCode.DateTime:
468		case TypeCode.Decimal:
469		case TypeCode.DBNull:
470	42	return true;
471		default:
472	264	return false;
473		}
474	306	}
475
476		internal static bool IsJsonPrimitiveType(Type type)
477		{
478	309	if (ReflectionUtils.IsNullableType(type))
479	8	type = Nullable.GetUnderlyingType(type);
480
481		#if !PocketPC && !NET20
482	309	if (type == typeof(DateTimeOffset))
483	2	return true;
484		#endif
485	307	if (type == typeof(byte[]))
486	1	return true;
487
488	306	return IsJsonPrimitiveTypeCode(Type.GetTypeCode(type));
489	309	}
490
491		internal static bool IsJsonPrimitive(object value)
492		{
493	0	if (value == null)
494	0	return true;
495
496	0	IConvertible convertible = value as IConvertible;
497
498	0	if (convertible != null)
499	0	return IsJsonPrimitiveTypeCode(convertible.GetTypeCode());
500