chore: 初始化平芝550kVMesProject项目

Common/00-1Json8.3/Json8.3/Converters/BinaryConverter.cs

@@ -0,0 +1,201 @@
+#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 !(DOTNET || PORTABLE40 || PORTABLE)
+using System;
+using System.Data.SqlTypes;
+using System.Globalization;
+using Newtonsoft.Json.Utilities;
+using System.Collections.Generic;
+
+namespace Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a binary value to and from a base 64 string value.
+    /// </summary>
+    public class BinaryConverter : JsonConverter
+    {
+#if !NET20
+        private const string BinaryTypeName = "System.Data.Linq.Binary";
+        private const string BinaryToArrayName = "ToArray";
+        private ReflectionObject _reflectionObject;
+#endif
+
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            if (value == null)
+            {
+                writer.WriteNull();
+                return;
+            }
+
+            byte[] data = GetByteArray(value);
+
+            writer.WriteValue(data);
+        }
+
+        private byte[] GetByteArray(object value)
+        {
+#if !(NET20)
+            if (value.GetType().AssignableToTypeName(BinaryTypeName))
+            {
+                EnsureReflectionObject(value.GetType());
+                return (byte[])_reflectionObject.GetValue(value, BinaryToArrayName);
+            }
+#endif
+            if (value is SqlBinary)
+            {
+                return ((SqlBinary)value).Value;
+            }
+
+            throw new JsonSerializationException("Unexpected value type when writing binary: {0}".FormatWith(CultureInfo.InvariantCulture, value.GetType()));
+        }
+
+#if !NET20
+        private void EnsureReflectionObject(Type t)
+        {
+            if (_reflectionObject == null)
+            {
+                _reflectionObject = ReflectionObject.Create(t, t.GetConstructor(new[] { typeof(byte[]) }), BinaryToArrayName);
+            }
+        }
+#endif
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                if (!ReflectionUtils.IsNullable(objectType))
+                {
+                    throw JsonSerializationException.Create(reader, "Cannot convert null value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
+                }
+
+                return null;
+            }
+
+            byte[] data;
+
+            if (reader.TokenType == JsonToken.StartArray)
+            {
+                data = ReadByteArray(reader);
+            }
+            else if (reader.TokenType == JsonToken.String)
+            {
+                // current token is already at base64 string
+                // unable to call ReadAsBytes so do it the old fashion way
+                string encodedData = reader.Value.ToString();
+                data = Convert.FromBase64String(encodedData);
+            }
+            else
+            {
+                throw JsonSerializationException.Create(reader, "Unexpected token parsing binary. Expected String or StartArray, got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+            Type t = (ReflectionUtils.IsNullableType(objectType))
+                ? Nullable.GetUnderlyingType(objectType)
+                : objectType;
+
+#if !NET20
+            if (t.AssignableToTypeName(BinaryTypeName))
+            {
+                EnsureReflectionObject(t);
+
+                return _reflectionObject.Creator(data);
+            }
+#endif
+
+            if (t == typeof(SqlBinary))
+            {
+                return new SqlBinary(data);
+            }
+
+            throw JsonSerializationException.Create(reader, "Unexpected object type when writing binary: {0}".FormatWith(CultureInfo.InvariantCulture, objectType));
+        }
+
+        private byte[] ReadByteArray(JsonReader reader)
+        {
+            List<byte> byteList = new List<byte>();
+
+            while (reader.Read())
+            {
+                switch (reader.TokenType)
+                {
+                    case JsonToken.Integer:
+                        byteList.Add(Convert.ToByte(reader.Value, CultureInfo.InvariantCulture));
+                        break;
+                    case JsonToken.EndArray:
+                        return byteList.ToArray();
+                    case JsonToken.Comment:
+                        // skip
+                        break;
+                    default:
+                        throw JsonSerializationException.Create(reader, "Unexpected token when reading bytes: {0}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+                }
+            }
+
+            throw JsonSerializationException.Create(reader, "Unexpected end when reading bytes.");
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+#if !NET20
+            if (objectType.AssignableToTypeName(BinaryTypeName))
+            {
+                return true;
+            }
+#endif
+
+            if (objectType == typeof(SqlBinary) || objectType == typeof(SqlBinary?))
+            {
+                return true;
+            }
+
+            return false;
+        }
+    }
+}
+
+#endif

Common/00-1Json8.3/Json8.3/Converters/BsonObjectIdConverter.cs

@@ -0,0 +1,91 @@
+#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 Newtonsoft.Json.Bson;
+using System.Globalization;
+using Newtonsoft.Json.Utilities;
+
+namespace Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a <see cref="BsonObjectId"/> to and from JSON and BSON.
+    /// </summary>
+    public class BsonObjectIdConverter : JsonConverter
+    {
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            BsonObjectId objectId = (BsonObjectId)value;
+
+            BsonWriter bsonWriter = writer as BsonWriter;
+            if (bsonWriter != null)
+            {
+                bsonWriter.WriteObjectId(objectId.Value);
+            }
+            else
+            {
+                writer.WriteValue(objectId.Value);
+            }
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType != JsonToken.Bytes)
+            {
+                throw new JsonSerializationException("Expected Bytes but got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+            byte[] value = (byte[])reader.Value;
+
+            return new BsonObjectId(value);
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            return (objectType == typeof(BsonObjectId));
+        }
+    }
+}

Common/00-1Json8.3/Json8.3/Converters/CustomCreationConverter.cs

@@ -0,0 +1,104 @@
+#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.Reflection;
+using Newtonsoft.Json.Utilities;
+
+namespace Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Create a custom object
+    /// </summary>
+    /// <typeparam name="T">The object type to convert.</typeparam>
+    public abstract class CustomCreationConverter<T> : JsonConverter
+    {
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            throw new NotSupportedException("CustomCreationConverter should only be used while deserializing.");
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                return null;
+            }
+
+            T value = Create(objectType);
+            if (value == null)
+            {
+                throw new JsonSerializationException("No object created.");
+            }
+
+            serializer.Populate(reader, value);
+            return value;
+        }
+
+        /// <summary>
+        /// Creates an object which will then be populated by the serializer.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>The created object.</returns>
+        public abstract T Create(Type objectType);
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            return typeof(T).IsAssignableFrom(objectType);
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether this <see cref="JsonConverter"/> can write JSON.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if this <see cref="JsonConverter"/> can write JSON; otherwise, <c>false</c>.
+        /// </value>
+        public override bool CanWrite
+        {
+            get { return false; }
+        }
+    }
+}

Common/00-1Json8.3/Json8.3/Converters/DataSetConverter.cs

@@ -0,0 +1,119 @@
+#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 !(DOTNET || PORTABLE40 || PORTABLE)
+using System;
+using System.Data;
+using Newtonsoft.Json.Serialization;
+
+namespace Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a <see cref="DataSet"/> to and from JSON.
+    /// </summary>
+    public class DataSetConverter : JsonConverter
+    {
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            DataSet dataSet = (DataSet)value;
+            DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
+
+            DataTableConverter converter = new DataTableConverter();
+
+            writer.WriteStartObject();
+
+            foreach (DataTable table in dataSet.Tables)
+            {
+                writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(table.TableName) : table.TableName);
+
+                converter.WriteJson(writer, table, serializer);
+            }
+
+            writer.WriteEndObject();
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                return null;
+            }
+
+            // handle typed datasets
+            DataSet ds = (objectType == typeof(DataSet))
+                ? new DataSet()
+                : (DataSet)Activator.CreateInstance(objectType);
+
+            DataTableConverter converter = new DataTableConverter();
+
+            reader.ReadAndAssert();
+
+            while (reader.TokenType == JsonToken.PropertyName)
+            {
+                DataTable dt = ds.Tables[(string)reader.Value];
+                bool exists = (dt != null);
+
+                dt = (DataTable)converter.ReadJson(reader, typeof(DataTable), dt, serializer);
+
+                if (!exists)
+                {
+                    ds.Tables.Add(dt);
+                }
+
+                reader.ReadAndAssert();
+            }
+
+            return ds;
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified value type.
+        /// </summary>
+        /// <param name="valueType">Type of the value.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified value type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type valueType)
+        {
+            return typeof(DataSet).IsAssignableFrom(valueType);
+        }
+    }
+}
+
+#endif

Common/00-1Json8.3/Json8.3/Converters/DataTableConverter.cs

@@ -0,0 +1,244 @@
+#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 !(DOTNET || PORTABLE40 || PORTABLE)
+using System.Collections.Generic;
+using System.Globalization;
+using Newtonsoft.Json.Utilities;
+using System;
+using System.Data;
+using Newtonsoft.Json.Serialization;
+
+namespace Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a <see cref="DataTable"/> to and from JSON.
+    /// </summary>
+    public class DataTableConverter : JsonConverter
+    {
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            DataTable table = (DataTable)value;
+            DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
+
+            writer.WriteStartArray();
+
+            foreach (DataRow row in table.Rows)
+            {
+                writer.WriteStartObject();
+                foreach (DataColumn column in row.Table.Columns)
+                {
+                    object columnValue = row[column];
+
+                    if (serializer.NullValueHandling == NullValueHandling.Ignore && (columnValue == null || columnValue == DBNull.Value))
+                    {
+                        continue;
+                    }
+
+                    writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(column.ColumnName) : column.ColumnName);
+                    serializer.Serialize(writer, columnValue);
+                }
+                writer.WriteEndObject();
+            }
+
+            writer.WriteEndArray();
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                return null;
+            }
+
+            DataTable dt = existingValue as DataTable;
+
+            if (dt == null)
+            {
+                // handle typed datasets
+                dt = (objectType == typeof(DataTable))
+                    ? new DataTable()
+                    : (DataTable)Activator.CreateInstance(objectType);
+            }
+
+            // DataTable is inside a DataSet
+            // populate the name from the property name
+            if (reader.TokenType == JsonToken.PropertyName)
+            {
+                dt.TableName = (string)reader.Value;
+
+                reader.ReadAndAssert();
+
+                if (reader.TokenType == JsonToken.Null)
+                {
+                    return dt;
+                }
+            }
+
+            if (reader.TokenType != JsonToken.StartArray)
+            {
+                throw JsonSerializationException.Create(reader, "Unexpected JSON token when reading DataTable. Expected StartArray, got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+            reader.ReadAndAssert();
+
+            while (reader.TokenType != JsonToken.EndArray)
+            {
+                CreateRow(reader, dt, serializer);
+
+                reader.ReadAndAssert();
+            }
+
+            return dt;
+        }
+
+        private static void CreateRow(JsonReader reader, DataTable dt, JsonSerializer serializer)
+        {
+            DataRow dr = dt.NewRow();
+            reader.ReadAndAssert();
+
+            while (reader.TokenType == JsonToken.PropertyName)
+            {
+                string columnName = (string)reader.Value;
+
+                reader.ReadAndAssert();
+
+                DataColumn column = dt.Columns[columnName];
+                if (column == null)
+                {
+                    Type columnType = GetColumnDataType(reader);
+                    column = new DataColumn(columnName, columnType);
+                    dt.Columns.Add(column);
+                }
+
+                if (column.DataType == typeof(DataTable))
+                {
+                    if (reader.TokenType == JsonToken.StartArray)
+                    {
+                        reader.ReadAndAssert();
+                    }
+
+                    DataTable nestedDt = new DataTable();
+
+                    while (reader.TokenType != JsonToken.EndArray)
+                    {
+                        CreateRow(reader, nestedDt, serializer);
+
+                        reader.ReadAndAssert();
+                    }
+
+                    dr[columnName] = nestedDt;
+                }
+                else if (column.DataType.IsArray && column.DataType != typeof(byte[]))
+                {
+                    if (reader.TokenType == JsonToken.StartArray)
+                    {
+                        reader.ReadAndAssert();
+                    }
+
+                    List<object> o = new List<object>();
+
+                    while (reader.TokenType != JsonToken.EndArray)
+                    {
+                        o.Add(reader.Value);
+                        reader.ReadAndAssert();
+                    }
+
+                    Array destinationArray = Array.CreateInstance(column.DataType.GetElementType(), o.Count);
+                    Array.Copy(o.ToArray(), destinationArray, o.Count);
+
+                    dr[columnName] = destinationArray;
+                }
+                else
+                {
+                    dr[columnName] = (reader.Value != null) ? serializer.Deserialize(reader, column.DataType) : DBNull.Value;
+                }
+
+                reader.ReadAndAssert();
+            }
+
+            dr.EndEdit();
+            dt.Rows.Add(dr);
+        }
+
+        private static Type GetColumnDataType(JsonReader reader)
+        {
+            JsonToken tokenType = reader.TokenType;
+
+            switch (tokenType)
+            {
+                case JsonToken.Integer:
+                case JsonToken.Boolean:
+                case JsonToken.Float:
+                case JsonToken.String:
+                case JsonToken.Date:
+                case JsonToken.Bytes:
+                    return reader.ValueType;
+                case JsonToken.Null:
+                case JsonToken.Undefined:
+                    return typeof(string);
+                case JsonToken.StartArray:
+                    reader.ReadAndAssert();
+                    if (reader.TokenType == JsonToken.StartObject)
+                    {
+                        return typeof(DataTable); // nested datatable
+                    }
+
+                    Type arrayType = GetColumnDataType(reader);
+                    return arrayType.MakeArrayType();
+                default:
+                    throw JsonSerializationException.Create(reader, "Unexpected JSON token when reading DataTable: {0}".FormatWith(CultureInfo.InvariantCulture, tokenType));
+            }
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified value type.
+        /// </summary>
+        /// <param name="valueType">Type of the value.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified value type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type valueType)
+        {
+            return typeof(DataTable).IsAssignableFrom(valueType);
+        }
+    }
+}
+
+#endif

Common/00-1Json8.3/Json8.3/Converters/DateTimeConverterBase.cs

@@ -0,0 +1,58 @@
+#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;
+
+namespace Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Provides a base class for converting a <see cref="DateTime"/> to and from JSON.
+    /// </summary>
+    public abstract class DateTimeConverterBase : JsonConverter
+    {
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            if (objectType == typeof(DateTime) || objectType == typeof(DateTime?))
+            {
+                return true;
+            }
+#if !NET20
+            if (objectType == typeof(DateTimeOffset) || objectType == typeof(DateTimeOffset?))
+            {
+                return true;
+            }
+#endif
+
+            return false;
+        }
+    }
+}

Common/00-1Json8.3/Json8.3/Converters/DiscriminatedUnionConverter.cs

@@ -0,0 +1,280 @@
+#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)
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+#if NET20
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+#endif
+using System.Reflection;
+using Newtonsoft.Json.Serialization;
+using System.Globalization;
+using Newtonsoft.Json.Utilities;
+
+namespace Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a F# discriminated union type to and from JSON.
+    /// </summary>
+    public class DiscriminatedUnionConverter : JsonConverter
+    {
+        #region UnionDefinition
+        internal class Union
+        {
+            public List<UnionCase> Cases;
+            public FSharpFunction TagReader { get; set; }
+        }
+
+        internal class UnionCase
+        {
+            public int Tag;
+            public string Name;
+            public PropertyInfo[] Fields;
+            public FSharpFunction FieldReader;
+            public FSharpFunction Constructor;
+        }
+        #endregion
+
+        private const string CasePropertyName = "Case";
+        private const string FieldsPropertyName = "Fields";
+
+        private static readonly ThreadSafeStore<Type, Union> UnionCache = new ThreadSafeStore<Type, Union>(CreateUnion);
+        private static readonly ThreadSafeStore<Type, Type> UnionTypeLookupCache = new ThreadSafeStore<Type, Type>(CreateUnionTypeLookup);
+
+        private static Type CreateUnionTypeLookup(Type t)
+        {
+            // this lookup is because cases with fields are derived from union type
+            // need to get declaring type to avoid duplicate Unions in cache
+
+            // hacky but I can't find an API to get the declaring type without GetUnionCases
+            object[] cases = (object[])FSharpUtils.GetUnionCases(null, t, null);
+
+            object caseInfo = cases.First();
+
+            Type unionType = (Type)FSharpUtils.GetUnionCaseInfoDeclaringType(caseInfo);
+            return unionType;
+        }
+
+        private static Union CreateUnion(Type t)
+        {
+            Union u = new Union();
+
+            u.TagReader = (FSharpFunction)FSharpUtils.PreComputeUnionTagReader(null, t, null);
+            u.Cases = new List<UnionCase>();
+
+            object[] cases = (object[])FSharpUtils.GetUnionCases(null, t, null);
+
+            foreach (object unionCaseInfo in cases)
+            {
+                UnionCase unionCase = new UnionCase();
+                unionCase.Tag = (int)FSharpUtils.GetUnionCaseInfoTag(unionCaseInfo);
+                unionCase.Name = (string)FSharpUtils.GetUnionCaseInfoName(unionCaseInfo);
+                unionCase.Fields = (PropertyInfo[])FSharpUtils.GetUnionCaseInfoFields(unionCaseInfo);
+                unionCase.FieldReader = (FSharpFunction)FSharpUtils.PreComputeUnionReader(null, unionCaseInfo, null);
+                unionCase.Constructor = (FSharpFunction)FSharpUtils.PreComputeUnionConstructor(null, unionCaseInfo, null);
+
+                u.Cases.Add(unionCase);
+            }
+
+            return u;
+        }
+
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
+
+            Type unionType = UnionTypeLookupCache.Get(value.GetType());
+            Union union = UnionCache.Get(unionType);
+
+            int tag = (int)union.TagReader.Invoke(value);
+            UnionCase caseInfo = union.Cases.Single(c => c.Tag == tag);
+
+            writer.WriteStartObject();
+            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(CasePropertyName) : CasePropertyName);
+            writer.WriteValue(caseInfo.Name);
+            if (caseInfo.Fields != null && caseInfo.Fields.Length > 0)
+            {
+                object[] fields = (object[])caseInfo.FieldReader.Invoke(value);
+
+                writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(FieldsPropertyName) : FieldsPropertyName);
+                writer.WriteStartArray();
+                foreach (object field in fields)
+                {
+                    serializer.Serialize(writer, field);
+                }
+                writer.WriteEndArray();
+            }
+            writer.WriteEndObject();
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                return null;
+            }
+
+            UnionCase caseInfo = null;
+            string caseName = null;
+            JArray fields = null;
+
+            // start object
+            reader.ReadAndAssert();
+
+            while (reader.TokenType == JsonToken.PropertyName)
+            {
+                string propertyName = reader.Value.ToString();
+                if (string.Equals(propertyName, CasePropertyName, StringComparison.OrdinalIgnoreCase))
+                {
+                    reader.ReadAndAssert();
+
+                    Union union = UnionCache.Get(objectType);
+
+                    caseName = reader.Value.ToString();
+
+                    caseInfo = union.Cases.SingleOrDefault(c => c.Name == caseName);
+
+                    if (caseInfo == null)
+                    {
+                        throw JsonSerializationException.Create(reader, "No union type found with the name '{0}'.".FormatWith(CultureInfo.InvariantCulture, caseName));
+                    }
+                }
+                else if (string.Equals(propertyName, FieldsPropertyName, StringComparison.OrdinalIgnoreCase))
+                {
+                    reader.ReadAndAssert();
+                    if (reader.TokenType != JsonToken.StartArray)
+                    {
+                        throw JsonSerializationException.Create(reader, "Union fields must been an array.");
+                    }
+
+                    fields = (JArray)JToken.ReadFrom(reader);
+                }
+                else
+                {
+                    throw JsonSerializationException.Create(reader, "Unexpected property '{0}' found when reading union.".FormatWith(CultureInfo.InvariantCulture, propertyName));
+                }
+
+                reader.ReadAndAssert();
+            }
+
+            if (caseInfo == null)
+            {
+                throw JsonSerializationException.Create(reader, "No '{0}' property with union name found.".FormatWith(CultureInfo.InvariantCulture, CasePropertyName));
+            }
+
+            object[] typedFieldValues = new object[caseInfo.Fields.Length];
+
+            if (caseInfo.Fields.Length > 0 && fields == null)
+            {
+                throw JsonSerializationException.Create(reader, "No '{0}' property with union fields found.".FormatWith(CultureInfo.InvariantCulture, FieldsPropertyName));
+            }
+
+            if (fields != null)
+            {
+                if (caseInfo.Fields.Length != fields.Count)
+                {
+                    throw JsonSerializationException.Create(reader, "The number of field values does not match the number of properties defined by union '{0}'.".FormatWith(CultureInfo.InvariantCulture, caseName));
+                }
+
+                for (int i = 0; i < fields.Count; i++)
+                {
+                    JToken t = fields[i];
+                    PropertyInfo fieldProperty = caseInfo.Fields[i];
+
+                    typedFieldValues[i] = t.ToObject(fieldProperty.PropertyType, serializer);
+                }
+            }
+
+            object[] args = { typedFieldValues };
+
+            return caseInfo.Constructor.Invoke(args);
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            if (typeof(IEnumerable).IsAssignableFrom(objectType))
+            {
+                return false;
+            }
+
+            // all fsharp objects have CompilationMappingAttribute
+            // get the fsharp assembly from the attribute and initialize latebound methods
+            object[] attributes;
+#if !(DOTNET || PORTABLE)
+            attributes = objectType.GetCustomAttributes(true);
+#else
+            attributes = objectType.GetTypeInfo().GetCustomAttributes(true).ToArray();
+#endif
+
+            bool isFSharpType = false;
+            foreach (object attribute in attributes)
+            {
+                Type attributeType = attribute.GetType();
+                if (attributeType.FullName == "Microsoft.FSharp.Core.CompilationMappingAttribute")
+                {
+                    FSharpUtils.EnsureInitialized(attributeType.Assembly());
+
+                    isFSharpType = true;
+                    break;
+                }
+            }
+
+            if (!isFSharpType)
+            {
+                return false;
+            }
+
+            return (bool)FSharpUtils.IsUnion(null, objectType, null);
+        }
+    }
+}
+
+#endif

Common/00-1Json8.3/Json8.3/Converters/EntityKeyMemberConverter.cs

@@ -0,0 +1,157 @@
+#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 !(NET20 || DOTNET || PORTABLE40 || PORTABLE)
+using System;
+using Newtonsoft.Json.Serialization;
+using System.Globalization;
+using Newtonsoft.Json.Utilities;
+
+namespace Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts an Entity Framework EntityKey to and from JSON.
+    /// </summary>
+    public class EntityKeyMemberConverter : JsonConverter
+    {
+        private const string EntityKeyMemberFullTypeName = "System.Data.EntityKeyMember";
+
+        private const string KeyPropertyName = "Key";
+        private const string TypePropertyName = "Type";
+        private const string ValuePropertyName = "Value";
+
+        private static ReflectionObject _reflectionObject;
+
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            EnsureReflectionObject(value.GetType());
+
+            DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
+
+            string keyName = (string)_reflectionObject.GetValue(value, KeyPropertyName);
+            object keyValue = _reflectionObject.GetValue(value, ValuePropertyName);
+
+            Type keyValueType = (keyValue != null) ? keyValue.GetType() : null;
+
+            writer.WriteStartObject();
+            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyPropertyName) : KeyPropertyName);
+            writer.WriteValue(keyName);
+            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(TypePropertyName) : TypePropertyName);
+            writer.WriteValue((keyValueType != null) ? keyValueType.FullName : null);
+
+            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValuePropertyName) : ValuePropertyName);
+
+            if (keyValueType != null)
+            {
+                string valueJson;
+                if (JsonSerializerInternalWriter.TryConvertToString(keyValue, keyValueType, out valueJson))
+                {
+                    writer.WriteValue(valueJson);
+                }
+                else
+                {
+                    writer.WriteValue(keyValue);
+                }
+            }
+            else
+            {
+                writer.WriteNull();
+            }
+
+            writer.WriteEndObject();
+        }
+
+        private static void ReadAndAssertProperty(JsonReader reader, string propertyName)
+        {
+            reader.ReadAndAssert();
+
+            if (reader.TokenType != JsonToken.PropertyName || !string.Equals(reader.Value.ToString(), propertyName, StringComparison.OrdinalIgnoreCase))
+            {
+                throw new JsonSerializationException("Expected JSON property '{0}'.".FormatWith(CultureInfo.InvariantCulture, propertyName));
+            }
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            EnsureReflectionObject(objectType);
+
+            object entityKeyMember = _reflectionObject.Creator();
+
+            ReadAndAssertProperty(reader, KeyPropertyName);
+            reader.ReadAndAssert();
+            _reflectionObject.SetValue(entityKeyMember, KeyPropertyName, reader.Value.ToString());
+
+            ReadAndAssertProperty(reader, TypePropertyName);
+            reader.ReadAndAssert();
+            string type = reader.Value.ToString();
+
+            Type t = Type.GetType(type);
+
+            ReadAndAssertProperty(reader, ValuePropertyName);
+            reader.ReadAndAssert();
+            _reflectionObject.SetValue(entityKeyMember, ValuePropertyName, serializer.Deserialize(reader, t));
+
+            reader.ReadAndAssert();
+
+            return entityKeyMember;
+        }
+
+        private static void EnsureReflectionObject(Type objectType)
+        {
+            if (_reflectionObject == null)
+            {
+                _reflectionObject = ReflectionObject.Create(objectType, KeyPropertyName, ValuePropertyName);
+            }
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType.AssignableToTypeName(EntityKeyMemberFullTypeName);
+        }
+    }
+}
+
+#endif

Common/00-1Json8.3/Json8.3/Converters/ExpandoObjectConverter.cs

@@ -0,0 +1,168 @@
+#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 || PORTABLE40)
+
+using System;
+using System.Collections.Generic;
+using System.Dynamic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using Newtonsoft.Json.Utilities;
+
+namespace Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts an ExpandoObject to and from JSON.
+    /// </summary>
+    public class ExpandoObjectConverter : JsonConverter
+    {
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            // can write is set to false
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            return ReadValue(reader);
+        }
+
+        private object ReadValue(JsonReader reader)
+        {
+            if (!reader.MoveToContent())
+            {
+                throw JsonSerializationException.Create(reader, "Unexpected end when reading ExpandoObject.");
+            }
+
+            switch (reader.TokenType)
+            {
+                case JsonToken.StartObject:
+                    return ReadObject(reader);
+                case JsonToken.StartArray:
+                    return ReadList(reader);
+                default:
+                    if (JsonTokenUtils.IsPrimitiveToken(reader.TokenType))
+                    {
+                        return reader.Value;
+                    }
+
+                    throw JsonSerializationException.Create(reader, "Unexpected token when converting ExpandoObject: {0}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+        }
+
+        private object ReadList(JsonReader reader)
+        {
+            IList<object> list = new List<object>();
+
+            while (reader.Read())
+            {
+                switch (reader.TokenType)
+                {
+                    case JsonToken.Comment:
+                        break;
+                    default:
+                        object v = ReadValue(reader);
+
+                        list.Add(v);
+                        break;
+                    case JsonToken.EndArray:
+                        return list;
+                }
+            }
+
+            throw JsonSerializationException.Create(reader, "Unexpected end when reading ExpandoObject.");
+        }
+
+        private object ReadObject(JsonReader reader)
+        {
+            IDictionary<string, object> expandoObject = new ExpandoObject();
+
+            while (reader.Read())
+            {
+                switch (reader.TokenType)
+                {
+                    case JsonToken.PropertyName:
+                        string propertyName = reader.Value.ToString();
+
+                        if (!reader.Read())
+                        {
+                            throw JsonSerializationException.Create(reader, "Unexpected end when reading ExpandoObject.");
+                        }
+
+                        object v = ReadValue(reader);
+
+                        expandoObject[propertyName] = v;
+                        break;
+                    case JsonToken.Comment:
+                        break;
+                    case JsonToken.EndObject:
+                        return expandoObject;
+                }
+            }
+
+            throw JsonSerializationException.Create(reader, "Unexpected end when reading ExpandoObject.");
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            return (objectType == typeof(ExpandoObject));
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether this <see cref="JsonConverter"/> can write JSON.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if this <see cref="JsonConverter"/> can write JSON; otherwise, <c>false</c>.
+        /// </value>
+        public override bool CanWrite
+        {
+            get { return false; }
+        }
+    }
+}
+
+#endif

Common/00-1Json8.3/Json8.3/Converters/IsoDateTimeConverter.cs

@@ -0,0 +1,197 @@
+#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.Globalization;
+using Newtonsoft.Json.Utilities;
+
+namespace Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a <see cref="DateTime"/> to and from the ISO 8601 date format (e.g. 2008-04-12T12:53Z).
+    /// </summary>
+    public class IsoDateTimeConverter : DateTimeConverterBase
+    {
+        private const string DefaultDateTimeFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK";
+
+        private DateTimeStyles _dateTimeStyles = DateTimeStyles.RoundtripKind;
+        private string _dateTimeFormat;
+        private CultureInfo _culture;
+
+        /// <summary>
+        /// Gets or sets the date time styles used when converting a date to and from JSON.
+        /// </summary>
+        /// <value>The date time styles used when converting a date to and from JSON.</value>
+        public DateTimeStyles DateTimeStyles
+        {
+            get { return _dateTimeStyles; }
+            set { _dateTimeStyles = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the date time format used when converting a date to and from JSON.
+        /// </summary>
+        /// <value>The date time format used when converting a date to and from JSON.</value>
+        public string DateTimeFormat
+        {
+            get { return _dateTimeFormat ?? string.Empty; }
+            set { _dateTimeFormat = StringUtils.NullEmptyString(value); }
+        }
+
+        /// <summary>
+        /// Gets or sets the culture used when converting a date to and from JSON.
+        /// </summary>
+        /// <value>The culture used when converting a date to and from JSON.</value>
+        public CultureInfo Culture
+        {
+            get { return _culture ?? CultureInfo.CurrentCulture; }
+            set { _culture = value; }
+        }
+
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            string text;
+
+            if (value is DateTime)
+            {
+                DateTime dateTime = (DateTime)value;
+
+                if ((_dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal
+                    || (_dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal)
+                {
+                    dateTime = dateTime.ToUniversalTime();
+                }
+
+                text = dateTime.ToString(_dateTimeFormat ?? DefaultDateTimeFormat, Culture);
+            }
+#if !NET20
+            else if (value is DateTimeOffset)
+            {
+                DateTimeOffset dateTimeOffset = (DateTimeOffset)value;
+                if ((_dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal
+                    || (_dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal)
+                {
+                    dateTimeOffset = dateTimeOffset.ToUniversalTime();
+                }
+
+                text = dateTimeOffset.ToString(_dateTimeFormat ?? DefaultDateTimeFormat, Culture);
+            }
+#endif
+            else
+            {
+                throw new JsonSerializationException("Unexpected value when converting date. Expected DateTime or DateTimeOffset, got {0}.".FormatWith(CultureInfo.InvariantCulture, ReflectionUtils.GetObjectType(value)));
+            }
+
+            writer.WriteValue(text);
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            bool nullable = ReflectionUtils.IsNullableType(objectType);
+#if !NET20
+            Type t = (nullable)
+                ? Nullable.GetUnderlyingType(objectType)
+                : objectType;
+#endif
+
+            if (reader.TokenType == JsonToken.Null)
+            {
+                if (!ReflectionUtils.IsNullableType(objectType))
+                {
+                    throw JsonSerializationException.Create(reader, "Cannot convert null value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
+                }
+
+                return null;
+            }
+
+            if (reader.TokenType == JsonToken.Date)
+            {
+#if !NET20
+                if (t == typeof(DateTimeOffset))
+                {
+                    return (reader.Value is DateTimeOffset) ? reader.Value : new DateTimeOffset((DateTime)reader.Value);
+                }
+
+                // converter is expected to return a DateTime
+                if (reader.Value is DateTimeOffset)
+                {
+                    return ((DateTimeOffset)reader.Value).DateTime;
+                }
+#endif
+
+                return reader.Value;
+            }
+
+            if (reader.TokenType != JsonToken.String)
+            {
+                throw JsonSerializationException.Create(reader, "Unexpected token parsing date. Expected String, got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+            string dateText = reader.Value.ToString();
+
+            if (string.IsNullOrEmpty(dateText) && nullable)
+            {
+                return null;
+            }
+
+#if !NET20
+            if (t == typeof(DateTimeOffset))
+            {
+                if (!string.IsNullOrEmpty(_dateTimeFormat))
+                {
+                    return DateTimeOffset.ParseExact(dateText, _dateTimeFormat, Culture, _dateTimeStyles);
+                }
+                else
+                {
+                    return DateTimeOffset.Parse(dateText, Culture, _dateTimeStyles);
+                }
+            }
+#endif
+
+            if (!string.IsNullOrEmpty(_dateTimeFormat))
+            {
+                return DateTime.ParseExact(dateText, _dateTimeFormat, Culture, _dateTimeStyles);
+            }
+            else
+            {
+                return DateTime.Parse(dateText, Culture, _dateTimeStyles);
+            }
+        }
+    }
+}

Common/00-1Json8.3/Json8.3/Converters/JavaScriptDateTimeConverter.cs

@@ -0,0 +1,127 @@
+#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.Globalization;
+using Newtonsoft.Json.Utilities;
+
+namespace Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a <see cref="DateTime"/> to and from a JavaScript date constructor (e.g. new Date(52231943)).
+    /// </summary>
+    public class JavaScriptDateTimeConverter : DateTimeConverterBase
+    {
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            long ticks;
+
+            if (value is DateTime)
+            {
+                DateTime dateTime = (DateTime)value;
+                DateTime utcDateTime = dateTime.ToUniversalTime();
+                ticks = DateTimeUtils.ConvertDateTimeToJavaScriptTicks(utcDateTime);
+            }
+#if !NET20
+            else if (value is DateTimeOffset)
+            {
+                DateTimeOffset dateTimeOffset = (DateTimeOffset)value;
+                DateTimeOffset utcDateTimeOffset = dateTimeOffset.ToUniversalTime();
+                ticks = DateTimeUtils.ConvertDateTimeToJavaScriptTicks(utcDateTimeOffset.UtcDateTime);
+            }
+#endif
+            else
+            {
+                throw new JsonSerializationException("Expected date object value.");
+            }
+
+            writer.WriteStartConstructor("Date");
+            writer.WriteValue(ticks);
+            writer.WriteEndConstructor();
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing property value of the JSON that is being converted.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                if (!ReflectionUtils.IsNullable(objectType))
+                {
+                    throw JsonSerializationException.Create(reader, "Cannot convert null value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
+                }
+
+                return null;
+            }
+
+            if (reader.TokenType != JsonToken.StartConstructor || !string.Equals(reader.Value.ToString(), "Date", StringComparison.Ordinal))
+            {
+                throw JsonSerializationException.Create(reader, "Unexpected token or value when parsing date. Token: {0}, Value: {1}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType, reader.Value));
+            }
+
+            reader.Read();
+
+            if (reader.TokenType != JsonToken.Integer)
+            {
+                throw JsonSerializationException.Create(reader, "Unexpected token parsing date. Expected Integer, got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+            long ticks = (long)reader.Value;
+
+            DateTime d = DateTimeUtils.ConvertJavaScriptTicksToDateTime(ticks);
+
+            reader.Read();
+
+            if (reader.TokenType != JsonToken.EndConstructor)
+            {
+                throw JsonSerializationException.Create(reader, "Unexpected token parsing date. Expected EndConstructor, got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+#if !NET20
+            Type t = (ReflectionUtils.IsNullableType(objectType))
+                ? Nullable.GetUnderlyingType(objectType)
+                : objectType;
+            if (t == typeof(DateTimeOffset))
+            {
+                return new DateTimeOffset(d);
+            }
+#endif
+
+            return d;
+        }
+    }
+}

Common/00-1Json8.3/Json8.3/Converters/JsonValueConverter.cs

@@ -0,0 +1,225 @@
+#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 NETFX_CORE
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Security;
+using Newtonsoft.Json.Utilities;
+using Windows.Data.Json;
+
+namespace Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a <see cref="IJsonValue"/> to and from JSON.
+    /// </summary>
+    public class JsonValueConverter : JsonConverter
+    {
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            WriteJsonValue(writer, (IJsonValue)value);
+        }
+
+        private void WriteJsonValue(JsonWriter writer, IJsonValue value)
+        {
+            switch (value.ValueType)
+            {
+                case JsonValueType.Array:
+                {
+                    JsonArray a = value.GetArray();
+                    writer.WriteStartArray();
+                    for (int i = 0; i < a.Count; i++)
+                    {
+                        WriteJsonValue(writer, a[i]);
+                    }
+                    writer.WriteEndArray();
+                }
+                    break;
+                case JsonValueType.Boolean:
+                {
+                    writer.WriteValue(value.GetBoolean());
+                }
+                    break;
+                case JsonValueType.Null:
+                {
+                    writer.WriteNull();
+                }
+                    break;
+                case JsonValueType.Number:
+                {
+                    // JsonValue doesn't support integers
+                    // serialize whole numbers without a decimal point
+                    double d = value.GetNumber();
+                    bool isInteger = (d % 1 == 0);
+                    if (isInteger && d <= long.MaxValue && d >= long.MinValue)
+                        writer.WriteValue(Convert.ToInt64(d));
+                    else
+                        writer.WriteValue(d);
+                }
+                    break;
+                case JsonValueType.Object:
+                {
+                    JsonObject o = value.GetObject();
+                    writer.WriteStartObject();
+                    foreach (KeyValuePair<string, IJsonValue> v in o)
+                    {
+                        writer.WritePropertyName(v.Key);
+                        WriteJsonValue(writer, v.Value);
+                    }
+                    writer.WriteEndObject();
+                }
+                    break;
+                case JsonValueType.String:
+                {
+                    writer.WriteValue(value.GetString());
+                }
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException("ValueType");
+            }
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.None)
+                reader.Read();
+
+            IJsonValue value = CreateJsonValue(reader);
+
+            if (!objectType.IsAssignableFrom(value.GetType()))
+                throw JsonSerializationException.Create(reader, "Could not convert '{0}' to '{1}'.".FormatWith(CultureInfo.InvariantCulture, value.GetType(), objectType));
+
+            return value;
+        }
+
+        private IJsonValue CreateJsonValue(JsonReader reader)
+        {
+            while (reader.TokenType == JsonToken.Comment)
+            {
+                if (!reader.Read())
+                    throw JsonSerializationException.Create(reader, "Unexpected end.");
+            }
+
+            switch (reader.TokenType)
+            {
+                case JsonToken.StartObject:
+                {
+                    return CreateJsonObject(reader);
+                }
+                case JsonToken.StartArray:
+                {
+                    JsonArray a = new JsonArray();
+
+                    while (reader.Read())
+                    {
+                        switch (reader.TokenType)
+                        {
+                            case JsonToken.EndArray:
+                                return a;
+                            default:
+                                IJsonValue value = CreateJsonValue(reader);
+                                a.Add(value);
+                                break;
+                        }
+                    }
+                }
+                    break;
+                case JsonToken.Integer:
+                case JsonToken.Float:
+                    return JsonValue.CreateNumberValue(Convert.ToDouble(reader.Value, CultureInfo.InvariantCulture));
+                case JsonToken.String:
+                    return JsonValue.CreateStringValue(reader.Value.ToString());
+                case JsonToken.Boolean:
+                    return JsonValue.CreateBooleanValue(Convert.ToBoolean(reader.Value, CultureInfo.InvariantCulture));
+                case JsonToken.Null:
+                    // surely there is a better way to create a null value than this?
+                    return JsonValue.Parse("null");
+                case JsonToken.Date:
+                    return JsonValue.CreateStringValue(reader.Value.ToString());
+                case JsonToken.Bytes:
+                    return JsonValue.CreateStringValue(reader.Value.ToString());
+                default:
+                    throw JsonSerializationException.Create(reader, "Unexpected or unsupported token: {0}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+            }
+
+            throw JsonSerializationException.Create(reader, "Unexpected end.");
+        }
+
+        private JsonObject CreateJsonObject(JsonReader reader)
+        {
+            JsonObject o = new JsonObject();
+            string propertyName = null;
+
+            while (reader.Read())
+            {
+                switch (reader.TokenType)
+                {
+                    case JsonToken.PropertyName:
+                        propertyName = (string)reader.Value;
+                        break;
+                    case JsonToken.EndObject:
+                        return o;
+                    case JsonToken.Comment:
+                        break;
+                    default:
+                        IJsonValue propertyValue = CreateJsonValue(reader);
+                        o.Add(propertyName, propertyValue);
+                        break;
+                }
+            }
+
+            throw JsonSerializationException.Create(reader, "Unexpected end.");
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            return typeof(IJsonValue).IsAssignableFrom(objectType);
+        }
+    }
+}
+#endif

Common/00-1Json8.3/Json8.3/Converters/KeyValuePairConverter.cs

@@ -0,0 +1,149 @@
+#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.Collections.Generic;
+using Newtonsoft.Json.Serialization;
+using Newtonsoft.Json.Utilities;
+using System.Reflection;
+
+namespace Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a <see cref="KeyValuePair{TKey,TValue}"/> to and from JSON.
+    /// </summary>
+    public class KeyValuePairConverter : JsonConverter
+    {
+        private const string KeyName = "Key";
+        private const string ValueName = "Value";
+
+        private static readonly ThreadSafeStore<Type, ReflectionObject> ReflectionObjectPerType = new ThreadSafeStore<Type, ReflectionObject>(InitializeReflectionObject);
+
+        private static ReflectionObject InitializeReflectionObject(Type t)
+        {
+            IList<Type> genericArguments = t.GetGenericArguments();
+            Type keyType = genericArguments[0];
+            Type valueType = genericArguments[1];
+
+            return ReflectionObject.Create(t, t.GetConstructor(new[] { keyType, valueType }), KeyName, ValueName);
+        }
+
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            ReflectionObject reflectionObject = ReflectionObjectPerType.Get(value.GetType());
+
+            DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
+
+            writer.WriteStartObject();
+            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyName) : KeyName);
+            serializer.Serialize(writer, reflectionObject.GetValue(value, KeyName), reflectionObject.GetType(KeyName));
+            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValueName) : ValueName);
+            serializer.Serialize(writer, reflectionObject.GetValue(value, ValueName), reflectionObject.GetType(ValueName));
+            writer.WriteEndObject();
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                if (!ReflectionUtils.IsNullableType(objectType))
+                {
+                    throw JsonSerializationException.Create(reader, "Cannot convert null value to KeyValuePair.");
+                }
+
+                return null;
+            }
+
+            object key = null;
+            object value = null;
+
+            reader.ReadAndAssert();
+
+            Type t = ReflectionUtils.IsNullableType(objectType)
+                ? Nullable.GetUnderlyingType(objectType)
+                : objectType;
+
+            ReflectionObject reflectionObject = ReflectionObjectPerType.Get(t);
+
+            while (reader.TokenType == JsonToken.PropertyName)
+            {
+                string propertyName = reader.Value.ToString();
+                if (string.Equals(propertyName, KeyName, StringComparison.OrdinalIgnoreCase))
+                {
+                    reader.ReadAndAssert();
+                    key = serializer.Deserialize(reader, reflectionObject.GetType(KeyName));
+                }
+                else if (string.Equals(propertyName, ValueName, StringComparison.OrdinalIgnoreCase))
+                {
+                    reader.ReadAndAssert();
+                    value = serializer.Deserialize(reader, reflectionObject.GetType(ValueName));
+                }
+                else
+                {
+                    reader.Skip();
+                }
+
+                reader.ReadAndAssert();
+            }
+
+            return reflectionObject.Creator(key, value);
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            Type t = (ReflectionUtils.IsNullableType(objectType))
+                ? Nullable.GetUnderlyingType(objectType)
+                : objectType;
+
+            if (t.IsValueType() && t.IsGenericType())
+            {
+                return (t.GetGenericTypeDefinition() == typeof(KeyValuePair<,>));
+            }
+
+            return false;
+        }
+    }
+}

Common/00-1Json8.3/Json8.3/Converters/RegexConverter.cs

@@ -0,0 +1,227 @@
+#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.Text.RegularExpressions;
+using Newtonsoft.Json.Bson;
+using System.Globalization;
+using Newtonsoft.Json.Serialization;
+
+namespace Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a <see cref="Regex"/> to and from JSON and BSON.
+    /// </summary>
+    public class RegexConverter : JsonConverter
+    {
+        private const string PatternName = "Pattern";
+        private const string OptionsName = "Options";
+
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            Regex regex = (Regex)value;
+
+            BsonWriter bsonWriter = writer as BsonWriter;
+            if (bsonWriter != null)
+            {
+                WriteBson(bsonWriter, regex);
+            }
+            else
+            {
+                WriteJson(writer, regex, serializer);
+            }
+        }
+
+        private bool HasFlag(RegexOptions options, RegexOptions flag)
+        {
+            return ((options & flag) == flag);
+        }
+
+        private void WriteBson(BsonWriter writer, Regex regex)
+        {
+            // Regular expression - The first cstring is the regex pattern, the second
+            // is the regex options string. Options are identified by characters, which 
+            // must be stored in alphabetical order. Valid options are 'i' for case 
+            // insensitive matching, 'm' for multiline matching, 'x' for verbose mode, 
+            // 'l' to make \w, \W, etc. locale dependent, 's' for dotall mode 
+            // ('.' matches everything), and 'u' to make \w, \W, etc. match unicode.
+
+            string options = null;
+
+            if (HasFlag(regex.Options, RegexOptions.IgnoreCase))
+            {
+                options += "i";
+            }
+
+            if (HasFlag(regex.Options, RegexOptions.Multiline))
+            {
+                options += "m";
+            }
+
+            if (HasFlag(regex.Options, RegexOptions.Singleline))
+            {
+                options += "s";
+            }
+
+            options += "u";
+
+            if (HasFlag(regex.Options, RegexOptions.ExplicitCapture))
+            {
+                options += "x";
+            }
+
+            writer.WriteRegex(regex.ToString(), options);
+        }
+
+        private void WriteJson(JsonWriter writer, Regex regex, JsonSerializer serializer)
+        {
+            DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
+
+            writer.WriteStartObject();
+            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(PatternName) : PatternName);
+            writer.WriteValue(regex.ToString());
+            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(OptionsName) : OptionsName);
+            serializer.Serialize(writer, regex.Options);
+            writer.WriteEndObject();
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.StartObject)
+            {
+                return ReadRegexObject(reader, serializer);
+            }
+
+            if (reader.TokenType == JsonToken.String)
+            {
+                return ReadRegexString(reader);
+            }
+
+            throw JsonSerializationException.Create(reader, "Unexpected token when reading Regex.");
+        }
+
+        private object ReadRegexString(JsonReader reader)
+        {
+            string regexText = (string)reader.Value;
+            int patternOptionDelimiterIndex = regexText.LastIndexOf('/');
+
+            string patternText = regexText.Substring(1, patternOptionDelimiterIndex - 1);
+            string optionsText = regexText.Substring(patternOptionDelimiterIndex + 1);
+
+            RegexOptions options = RegexOptions.None;
+            foreach (char c in optionsText)
+            {
+                switch (c)
+                {
+                    case 'i':
+                        options |= RegexOptions.IgnoreCase;
+                        break;
+                    case 'm':
+                        options |= RegexOptions.Multiline;
+                        break;
+                    case 's':
+                        options |= RegexOptions.Singleline;
+                        break;
+                    case 'x':
+                        options |= RegexOptions.ExplicitCapture;
+                        break;
+                }
+            }
+
+            return new Regex(patternText, options);
+        }
+
+        private Regex ReadRegexObject(JsonReader reader, JsonSerializer serializer)
+        {
+            string pattern = null;
+            RegexOptions? options = null;
+
+            while (reader.Read())
+            {
+                switch (reader.TokenType)
+                {
+                    case JsonToken.PropertyName:
+                        string propertyName = reader.Value.ToString();
+
+                        if (!reader.Read())
+                        {
+                            throw JsonSerializationException.Create(reader, "Unexpected end when reading Regex.");
+                        }
+
+                        if (string.Equals(propertyName, PatternName, StringComparison.OrdinalIgnoreCase))
+                        {
+                            pattern = (string)reader.Value;
+                        }
+                        else if (string.Equals(propertyName, OptionsName, StringComparison.OrdinalIgnoreCase))
+                        {
+                            options = serializer.Deserialize<RegexOptions>(reader);
+                        }
+                        else
+                        {
+                            reader.Skip();
+                        }
+                        break;
+                    case JsonToken.Comment:
+                        break;
+                    case JsonToken.EndObject:
+                        if (pattern == null)
+                        {
+                            throw JsonSerializationException.Create(reader, "Error deserializing Regex. No pattern found.");
+                        }
+
+                        return new Regex(pattern, options ?? RegexOptions.None);
+                }
+            }
+
+            throw JsonSerializationException.Create(reader, "Unexpected end when reading Regex.");
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            return (objectType == typeof(Regex));
+        }
+    }
+}

Common/00-1Json8.3/Json8.3/Converters/StringEnumConverter.cs

@@ -0,0 +1,175 @@
+#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.Collections.Generic;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.Serialization;
+using Newtonsoft.Json.Utilities;
+#if NET20
+using Newtonsoft.Json.Utilities.LinqBridge;
+#else
+using System.Linq;
+
+#endif
+
+namespace Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts an <see cref="Enum"/> to and from its name string value.
+    /// </summary>
+    public class StringEnumConverter : JsonConverter
+    {
+        /// <summary>
+        /// Gets or sets a value indicating whether the written enum text should be camel case.
+        /// </summary>
+        /// <value><c>true</c> if the written enum text will be camel case; otherwise, <c>false</c>.</value>
+        public bool CamelCaseText { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether integer values are allowed.
+        /// </summary>
+        /// <value><c>true</c> if integers are allowed; otherwise, <c>false</c>.</value>
+        public bool AllowIntegerValues { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StringEnumConverter"/> class.
+        /// </summary>
+        public StringEnumConverter()
+        {
+            AllowIntegerValues = true;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StringEnumConverter"/> class.
+        /// </summary>
+        /// <param name="camelCaseText"><c>true</c> if the written enum text will be camel case; otherwise, <c>false</c>.</param>
+        public StringEnumConverter(bool camelCaseText)
+            : this()
+        {
+            CamelCaseText = camelCaseText;
+        }
+
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            if (value == null)
+            {
+                writer.WriteNull();
+                return;
+            }
+
+            Enum e = (Enum)value;
+
+            string enumName = e.ToString("G");
+
+            if (char.IsNumber(enumName[0]) || enumName[0] == '-')
+            {
+                // enum value has no name so write number
+                writer.WriteValue(value);
+            }
+            else
+            {
+                Type enumType = e.GetType();
+
+                string finalName = EnumUtils.ToEnumName(enumType, enumName, CamelCaseText);
+
+                writer.WriteValue(finalName);
+            }
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing value of object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                if (!ReflectionUtils.IsNullableType(objectType))
+                {
+                    throw JsonSerializationException.Create(reader, "Cannot convert null value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
+                }
+
+                return null;
+            }
+
+            bool isNullable = ReflectionUtils.IsNullableType(objectType);
+            Type t = isNullable ? Nullable.GetUnderlyingType(objectType) : objectType;
+
+            try
+            {
+                if (reader.TokenType == JsonToken.String)
+                {
+                    string enumText = reader.Value.ToString();
+                    return EnumUtils.ParseEnumName(enumText, isNullable, t);
+                }
+
+                if (reader.TokenType == JsonToken.Integer)
+                {
+                    if (!AllowIntegerValues)
+                    {
+                        throw JsonSerializationException.Create(reader, "Integer value {0} is not allowed.".FormatWith(CultureInfo.InvariantCulture, reader.Value));
+                    }
+
+                    return ConvertUtils.ConvertOrCast(reader.Value, CultureInfo.InvariantCulture, t);
+                }
+            }
+            catch (Exception ex)
+            {
+                throw JsonSerializationException.Create(reader, "Error converting value {0} to type '{1}'.".FormatWith(CultureInfo.InvariantCulture, MiscellaneousUtils.FormatValueForPrint(reader.Value), objectType), ex);
+            }
+
+            // we don't actually expect to get here.
+            throw JsonSerializationException.Create(reader, "Unexpected token {0} when parsing enum.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// <c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            Type t = (ReflectionUtils.IsNullableType(objectType))
+                ? Nullable.GetUnderlyingType(objectType)
+                : objectType;
+
+            return t.IsEnum();
+        }
+    }
+}

Common/00-1Json8.3/Json8.3/Converters/VersionConverter.cs

@@ -0,0 +1,106 @@
+#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.Globalization;
+using Newtonsoft.Json.Utilities;
+
+namespace Newtonsoft.Json.Converters
+{
+    /// <summary>
+    /// Converts a <see cref="Version"/> to and from a string (e.g. "1.2.3.4").
+    /// </summary>
+    public class VersionConverter : JsonConverter
+    {
+        /// <summary>
+        /// Writes the JSON representation of the object.
+        /// </summary>
+        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            if (value == null)
+            {
+                writer.WriteNull();
+            }
+            else if (value is Version)
+            {
+                writer.WriteValue(value.ToString());
+            }
+            else
+            {
+                throw new JsonSerializationException("Expected Version object value");
+            }
+        }
+
+        /// <summary>
+        /// Reads the JSON representation of the object.
+        /// </summary>
+        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
+        /// <param name="objectType">Type of the object.</param>
+        /// <param name="existingValue">The existing property value of the JSON that is being converted.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        /// <returns>The object value.</returns>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                return null;
+            }
+            else
+            {
+                if (reader.TokenType == JsonToken.String)
+                {
+                    try
+                    {
+                        Version v = new Version((string)reader.Value);
+                        return v;
+                    }
+                    catch (Exception ex)
+                    {
+                        throw JsonSerializationException.Create(reader, "Error parsing version string: {0}".FormatWith(CultureInfo.InvariantCulture, reader.Value), ex);
+                    }
+                }
+                else
+                {
+                    throw JsonSerializationException.Create(reader, "Unexpected token or value when parsing version. Token: {0}, Value: {1}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType, reader.Value));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Determines whether this instance can convert the specified object type.
+        /// </summary>
+        /// <param name="objectType">Type of the object.</param>
+        /// <returns>
+        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType == typeof(Version);
+        }
+    }
+}