413 lines
14 KiB
C#
413 lines
14 KiB
C#
//
|
|
// JsonSerializationReader.cs
|
|
//
|
|
// Author:
|
|
// Atsushi Enomoto <atsushi@ximian.com>
|
|
//
|
|
// Copyright (C) 2008 Novell, Inc (http://www.novell.com)
|
|
//
|
|
// 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.
|
|
//
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Xml;
|
|
|
|
namespace System.Runtime.Serialization.Json
|
|
{
|
|
class JsonSerializationReader
|
|
{
|
|
DataContractJsonSerializer serializer;
|
|
XmlReader reader;
|
|
int serialized_object_count;
|
|
bool verify_object_name;
|
|
Dictionary<Type, TypeMap> typemaps = new Dictionary<Type, TypeMap> ();
|
|
Type root_type;
|
|
|
|
public JsonSerializationReader (DataContractJsonSerializer serializer, XmlReader reader, Type rootType, bool verifyObjectName)
|
|
{
|
|
this.serializer = serializer;
|
|
this.reader = reader;
|
|
this.root_type = rootType;
|
|
this.verify_object_name = verifyObjectName;
|
|
}
|
|
|
|
public XmlReader Reader {
|
|
get { return reader; }
|
|
}
|
|
|
|
public object ReadRoot ()
|
|
{
|
|
TypeMap rootMap = GetTypeMap (root_type);
|
|
|
|
object v = ReadObject (root_type);
|
|
return v;
|
|
}
|
|
|
|
public object ReadObject (Type type)
|
|
{
|
|
return ReadObject (type, null);
|
|
}
|
|
|
|
public object ReadObject (Type type, object instance)
|
|
{
|
|
if (serialized_object_count ++ == serializer.MaxItemsInObjectGraph)
|
|
throw SerializationError (String.Format ("The object graph exceeded the maximum object count '{0}' specified in the serializer", serializer.MaxItemsInObjectGraph));
|
|
|
|
bool nullable = false;
|
|
if (type.IsGenericType && type.GetGenericTypeDefinition () == typeof (Nullable<>)) {
|
|
nullable = true;
|
|
type = Nullable.GetUnderlyingType (type);
|
|
}
|
|
|
|
bool isNull = reader.GetAttribute ("type") == "null";
|
|
|
|
switch (Type.GetTypeCode (type)) {
|
|
case TypeCode.DBNull:
|
|
string dbn = reader.ReadElementContentAsString ();
|
|
if (dbn != String.Empty)
|
|
throw new SerializationException (String.Format ("The only expected DBNull value string is '{{}}'. Tha actual input was '{0}'.", dbn));
|
|
return DBNull.Value;
|
|
case TypeCode.String:
|
|
if (isNull) {
|
|
reader.ReadElementContentAsString ();
|
|
return null;
|
|
}
|
|
else
|
|
return reader.ReadElementContentAsString ();
|
|
case TypeCode.Char:
|
|
var c = reader.ReadElementContentAsString ();
|
|
if (c.Length > 1)
|
|
throw new XmlException ("Invalid JSON char");
|
|
return Char.Parse(c);
|
|
case TypeCode.Single:
|
|
case TypeCode.Double:
|
|
case TypeCode.Decimal:
|
|
return ReadValueType (type, nullable);
|
|
case TypeCode.Byte:
|
|
case TypeCode.SByte:
|
|
case TypeCode.Int16:
|
|
case TypeCode.Int32:
|
|
case TypeCode.UInt16:
|
|
case TypeCode.UInt32:
|
|
case TypeCode.Int64:
|
|
if (type.IsEnum)
|
|
return Enum.ToObject (type, Convert.ChangeType (reader.ReadElementContentAsLong (), Enum.GetUnderlyingType (type), null));
|
|
else
|
|
return ReadValueType (type, nullable);
|
|
case TypeCode.UInt64:
|
|
if (type.IsEnum)
|
|
return Enum.ToObject (type, Convert.ChangeType (reader.ReadElementContentAsDecimal (), Enum.GetUnderlyingType (type), null));
|
|
else
|
|
return ReadValueType (type, nullable);
|
|
case TypeCode.Boolean:
|
|
return ReadValueType (type, nullable);
|
|
case TypeCode.DateTime:
|
|
// it does not use ReadElementContentAsDateTime(). Different string format.
|
|
var s = reader.ReadElementContentAsString ();
|
|
if (s.Length < 2 || !s.StartsWith ("/Date(", StringComparison.Ordinal) || !s.EndsWith (")/", StringComparison.Ordinal)) {
|
|
if (nullable)
|
|
return null;
|
|
throw new XmlException ("Invalid JSON DateTime format. The value format should be '/Date(UnixTime)/'");
|
|
}
|
|
|
|
// The date can contain [SIGN]LONG, [SIGN]LONG+HOURSMINUTES or [SIGN]LONG-HOURSMINUTES
|
|
// the format for HOURSMINUTES is DDDD
|
|
int tidx = s.IndexOf ('-', 8);
|
|
if (tidx == -1)
|
|
tidx = s.IndexOf ('+', 8);
|
|
int minutes = 0;
|
|
if (tidx == -1){
|
|
s = s.Substring (6, s.Length - 8);
|
|
} else {
|
|
int offset;
|
|
int.TryParse (s.Substring (tidx+1, s.Length-3-tidx), out offset);
|
|
|
|
minutes = (offset % 100) + (offset / 100) * 60;
|
|
if (s [tidx] == '-')
|
|
minutes = -minutes;
|
|
|
|
s = s.Substring (6, tidx-6);
|
|
}
|
|
var date = new DateTime (1970, 1, 1).AddMilliseconds (long.Parse (s));
|
|
if (minutes != 0)
|
|
date = date.AddMinutes (minutes);
|
|
return date;
|
|
default:
|
|
if (type == typeof (Guid)) {
|
|
return new Guid (reader.ReadElementContentAsString ());
|
|
} else if (type == typeof (Uri)) {
|
|
if (isNull) {
|
|
reader.ReadElementContentAsString ();
|
|
return null;
|
|
}
|
|
else
|
|
return new Uri (reader.ReadElementContentAsString (), UriKind.RelativeOrAbsolute);
|
|
} else if (type == typeof (XmlQualifiedName)) {
|
|
s = reader.ReadElementContentAsString ();
|
|
int idx = s.IndexOf (':');
|
|
return idx < 0 ? new XmlQualifiedName (s) : new XmlQualifiedName (s.Substring (0, idx), s.Substring (idx + 1));
|
|
} else if (type != typeof (object)) {
|
|
// strongly-typed object
|
|
if (reader.IsEmptyElement) {
|
|
// empty -> null array or object
|
|
reader.Read ();
|
|
return null;
|
|
}
|
|
|
|
Type ct = GetCollectionElementType (type);
|
|
if (ct != null) {
|
|
return DeserializeGenericCollection (type, ct, instance);
|
|
} else {
|
|
TypeMap map = GetTypeMap (type);
|
|
return map.Deserialize (this, instance);
|
|
}
|
|
}
|
|
else
|
|
return ReadInstanceDrivenObject ();
|
|
}
|
|
}
|
|
|
|
object ReadValueType (Type type, bool nullable)
|
|
{
|
|
string s = reader.ReadElementContentAsString ();
|
|
return nullable && s.Trim ().Length == 0 ? null : Convert.ChangeType (s, type, CultureInfo.InvariantCulture);
|
|
}
|
|
|
|
|
|
Type GetRuntimeType (string name)
|
|
{
|
|
name = ToRuntimeTypeName (name);
|
|
if (serializer.KnownTypes != null)
|
|
foreach (Type t in serializer.KnownTypes)
|
|
if (t.FullName == name)
|
|
return t;
|
|
var ret = root_type.Assembly.GetType (name, false) ?? Type.GetType (name, false);
|
|
if (ret != null)
|
|
return ret;
|
|
|
|
// We probably have to iterate all the existing
|
|
// assemblies that are loaded in current domain.
|
|
foreach (var ass in AppDomain.CurrentDomain.GetAssemblies ()) {
|
|
ret = ass.GetType (name, false);
|
|
if (ret != null)
|
|
return ret;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
object ReadInstanceDrivenObject ()
|
|
{
|
|
string type = reader.GetAttribute ("type");
|
|
switch (type) {
|
|
case "null":
|
|
reader.Skip ();
|
|
return null;
|
|
case "object":
|
|
string runtimeType = reader.GetAttribute ("__type");
|
|
if (runtimeType != null) {
|
|
Type t = GetRuntimeType (runtimeType);
|
|
if (t == null)
|
|
throw SerializationError (String.Format ("Cannot load type '{0}'", runtimeType));
|
|
return ReadObject (t);
|
|
}
|
|
break;
|
|
}
|
|
string v = reader.ReadElementContentAsString ();
|
|
switch (type) {
|
|
case "boolean":
|
|
switch (v) {
|
|
case "true":
|
|
return true;
|
|
case "false":
|
|
return false;
|
|
default:
|
|
throw SerializationError (String.Format ("Invalid JSON boolean value: {0}", v));
|
|
}
|
|
case "string":
|
|
return v;
|
|
case "number":
|
|
int i;
|
|
if (int.TryParse (v, NumberStyles.None, CultureInfo.InvariantCulture, out i))
|
|
return i;
|
|
long l;
|
|
if (long.TryParse (v, NumberStyles.None, CultureInfo.InvariantCulture, out l))
|
|
return l;
|
|
ulong ul;
|
|
if (ulong.TryParse (v, NumberStyles.None, CultureInfo.InvariantCulture, out ul))
|
|
return ul;
|
|
double dbl;
|
|
if (double.TryParse (v, NumberStyles.None, CultureInfo.InvariantCulture, out dbl))
|
|
return dbl;
|
|
decimal dec;
|
|
if (decimal.TryParse (v, NumberStyles.None, CultureInfo.InvariantCulture, out dec))
|
|
return dec;
|
|
throw SerializationError (String.Format ("Invalid JSON input: {0}", v));
|
|
default:
|
|
throw SerializationError (String.Format ("Unexpected type: {0}", type));
|
|
}
|
|
}
|
|
|
|
string FormatTypeName (Type type)
|
|
{
|
|
return type.Namespace == null ? type.Name : String.Format ("{0}:#{1}", type.Name, type.Namespace);
|
|
}
|
|
|
|
string ToRuntimeTypeName (string s)
|
|
{
|
|
int idx = s.IndexOf (":#", StringComparison.Ordinal);
|
|
return idx < 0 ? s : String.Concat (s.Substring (idx + 2), ".", s.Substring (0, idx));
|
|
}
|
|
|
|
Type GetCollectionElementType (Type type)
|
|
{
|
|
if (type.IsArray)
|
|
return type.GetElementType ();
|
|
|
|
var inter = type.GetInterface ("System.Collections.Generic.IEnumerable`1", false);
|
|
if (inter != null)
|
|
return inter.GetGenericArguments () [0];
|
|
|
|
if (typeof (IEnumerable).IsAssignableFrom (type))
|
|
// return typeof(object) for mere collection.
|
|
return typeof (object);
|
|
else
|
|
return null;
|
|
}
|
|
|
|
object DeserializeGenericCollection (Type collectionType, Type elementType, object collectionInstance)
|
|
{
|
|
reader.ReadStartElement ();
|
|
object ret;
|
|
if (collectionType.IsInterface)
|
|
collectionType = typeof (List<>).MakeGenericType (elementType);
|
|
if (TypeMap.IsDictionary (collectionType)) {
|
|
if (collectionInstance == null)
|
|
collectionInstance = Activator.CreateInstance (collectionType);
|
|
|
|
var keyType = elementType.IsGenericType ? elementType.GetGenericArguments () [0] : typeof (object);
|
|
var valueType = elementType.IsGenericType ? elementType.GetGenericArguments () [1] : typeof (object);
|
|
MethodInfo add = collectionType.GetMethod ("Add", new Type [] { keyType, valueType });
|
|
|
|
for (reader.MoveToContent (); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent ()) {
|
|
if (!reader.IsStartElement ("item"))
|
|
throw SerializationError (String.Format ("Expected element 'item', but found '{0}' in namespace '{1}'", reader.LocalName, reader.NamespaceURI));
|
|
|
|
// reading a KeyValuePair in the form of <Key .../><Value .../>
|
|
reader.Read ();
|
|
reader.MoveToContent ();
|
|
object key = ReadObject (keyType);
|
|
reader.MoveToContent ();
|
|
object val = ReadObject (valueType);
|
|
reader.Read ();
|
|
add.Invoke (collectionInstance, new [] { key, val });
|
|
}
|
|
ret = collectionInstance;
|
|
} else if (typeof (IList).IsAssignableFrom (collectionType)) {
|
|
#if NET_2_1
|
|
Type listType = collectionType.IsArray ? typeof (List<>).MakeGenericType (elementType) : null;
|
|
#else
|
|
Type listType = collectionType.IsArray ? typeof (ArrayList) : null;
|
|
#endif
|
|
|
|
IList c;
|
|
if (collectionInstance == null)
|
|
c = (IList) Activator.CreateInstance (listType ?? collectionType);
|
|
else
|
|
c = (IList) collectionInstance;
|
|
|
|
for (reader.MoveToContent (); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent ()) {
|
|
if (!reader.IsStartElement ("item"))
|
|
throw SerializationError (String.Format ("Expected element 'item', but found '{0}' in namespace '{1}'", reader.LocalName, reader.NamespaceURI));
|
|
Type et = elementType == typeof (object) || elementType.IsAbstract ? null : elementType;
|
|
object elem = ReadObject (et ?? typeof (object));
|
|
c.Add (elem);
|
|
}
|
|
#if NET_2_1
|
|
if (collectionType.IsArray) {
|
|
Array array = Array.CreateInstance (elementType, c.Count);
|
|
c.CopyTo (array, 0);
|
|
ret = array;
|
|
}
|
|
else
|
|
ret = c;
|
|
#else
|
|
ret = collectionType.IsArray ? ((ArrayList) c).ToArray (elementType) : c;
|
|
#endif
|
|
} else {
|
|
if (collectionInstance == null)
|
|
collectionInstance = Activator.CreateInstance (collectionType);
|
|
|
|
MethodInfo add;
|
|
if (collectionInstance.GetType ().IsGenericType &&
|
|
collectionInstance.GetType ().GetGenericTypeDefinition () == typeof (LinkedList<>))
|
|
add = collectionType.GetMethod ("AddLast", new Type [] { elementType });
|
|
else
|
|
add = collectionType.GetMethod ("Add", new Type [] { elementType });
|
|
|
|
if (add == null) {
|
|
var icoll = typeof (ICollection<>).MakeGenericType (elementType);
|
|
if (icoll.IsAssignableFrom (collectionInstance.GetType ()))
|
|
add = icoll.GetMethod ("Add");
|
|
}
|
|
if (add == null)
|
|
throw new MissingMethodException (elementType.FullName, "Add");
|
|
|
|
for (reader.MoveToContent (); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent ()) {
|
|
if (!reader.IsStartElement ("item"))
|
|
throw SerializationError (String.Format ("Expected element 'item', but found '{0}' in namespace '{1}'", reader.LocalName, reader.NamespaceURI));
|
|
object element = ReadObject (elementType);
|
|
add.Invoke (collectionInstance, new object [] { element });
|
|
}
|
|
ret = collectionInstance;
|
|
}
|
|
|
|
reader.ReadEndElement ();
|
|
return ret;
|
|
}
|
|
|
|
TypeMap GetTypeMap (Type type)
|
|
{
|
|
TypeMap map;
|
|
if (!typemaps.TryGetValue (type, out map)) {
|
|
map = TypeMap.CreateTypeMap (type);
|
|
typemaps [type] = map;
|
|
}
|
|
return map;
|
|
}
|
|
|
|
Exception SerializationError (string basemsg)
|
|
{
|
|
IXmlLineInfo li = reader as IXmlLineInfo;
|
|
if (li == null || !li.HasLineInfo ())
|
|
return new SerializationException (basemsg);
|
|
else
|
|
return new SerializationException (String.Format ("{0}. Error at {1} ({2},{3})", basemsg, reader.BaseURI, li.LineNumber, li.LinePosition));
|
|
}
|
|
}
|
|
}
|