Files
mono/mcs/class/System.ServiceModel.Web/System.Runtime.Serialization.Json/JsonSerializationReader.cs
T
Chris Toshok 8718686805 in class/corlib/System.Collections.Generic/:
2009-12-06  Chris Toshok  <[email protected]>

	* KeyValuePair.cs: we need setters for Key and Value so they can
	be set via reflection from
	System.ServiceModel.System.Runtime.Serialization.Json.TypeMap.cs.

in class/System.ServiceModel.Web/System.Runtime.Serialization.Json/:
2009-12-06  Chris Toshok  <[email protected]>

	* JsonSerializationReader.cs (DeserializeGenericCollection): this
	is jb's (iirc) patch, actually.  Types subclassing from
	ICollection<T> need to be supported, and since it's an interface
	the implementation might be explicit.  So instead of groveling
	around in the actual type, we need to dispatch through the
	interface's method.

	* TypeMap.cs (CreateDefaultTypeMap): we need to include non-public
	properties, since KeyValuePair items must be able to write to Key
	and Value properties.

	* JsonReader.cs (ReadContent): for builtin values (null, true,
	false), use TryReadString instead of individual ReadChar's, since
	they aren't reversible if the string didn't match.  In the default
	case, if we're LameSilverlightLiseralParser, we need to push back
	the current character onto the stream -- this is because for
	netflix's AppConfig.json we were parsing "frameRatePolicy" as
	"rameRatePolicy" (the 'f' was triggering the "false" parsing).
	(class PushBackReader): add this class to unify all the pushing
	back of characters we need to do.  1 character (JsonReader's old
	"saved_char") isn't enough given that you could have a property
	named, e.g., "falsifiable", and we'd need 4 characters worth of
	pushback to recognize that correctly.

svn path=/trunk/mcs/; revision=147766
2009-12-07 07:39:17 +00:00

305 lines
9.9 KiB
C#

//
// JsonSerializationReader.cs
//
// Author:
// Atsushi Enomoto <[email protected]>
//
// 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.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)
{
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));
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:
return reader.ReadElementContentAsString ();
case TypeCode.Single:
return reader.ReadElementContentAsFloat ();
case TypeCode.Double:
return reader.ReadElementContentAsDouble ();
case TypeCode.Decimal:
return reader.ReadElementContentAsDecimal ();
case TypeCode.Byte:
case TypeCode.SByte:
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.UInt16:
case TypeCode.UInt32:
int i = reader.ReadElementContentAsInt ();
if (type.IsEnum)
return Enum.ToObject (type, (object)i);
else
return Convert.ChangeType (i, type, null);
case TypeCode.Int64:
case TypeCode.UInt64:
long l = reader.ReadElementContentAsLong ();
if (type.IsEnum)
return Enum.ToObject (type, (object)l);
else
return Convert.ChangeType (l, type, null);
case TypeCode.Boolean:
return reader.ReadElementContentAsBoolean ();
default:
if (type == typeof (Guid)) {
return new Guid (reader.ReadElementContentAsString ());
} else if (type == typeof (Uri)) {
return new Uri (reader.ReadElementContentAsString ());
} else if (type == typeof (XmlQualifiedName)) {
string 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 = GetCollectionType (type);
if (ct != null) {
return DeserializeGenericCollection (type, ct);
} else {
TypeMap map = GetTypeMap (type);
return map.Deserialize (this);
}
}
else
return ReadInstanceDrivenObject ();
}
}
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;
#if !NET_2_1 // how to do that in ML?
// 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;
}
#endif
return null;
}
object ReadInstanceDrivenObject ()
{
string type = reader.GetAttribute ("type");
if (type == "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);
}
}
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 "null":
if (v != "null")
throw SerializationError (String.Format ("Invalid JSON null value: {0}", v));
return null;
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 GetCollectionType (Type type)
{
if (type.IsArray)
return type.GetElementType ();
if (type.IsGenericType) {
// returns T for ICollection<T>
Type [] ifaces = type.GetInterfaces ();
foreach (Type i in ifaces)
if (i.IsGenericType && i.GetGenericTypeDefinition ().Equals (typeof (ICollection<>)))
return i.GetGenericArguments () [0];
}
if (typeof (IList).IsAssignableFrom (type))
// return typeof(object) for mere collection.
return typeof (object);
else
return null;
}
object DeserializeGenericCollection (Type collectionType, Type elementType)
{
reader.ReadStartElement ();
object ret;
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 = (IList) Activator.CreateInstance (listType ?? collectionType);
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
ret = c;
#else
ret = collectionType.IsArray ? ((ArrayList) c).ToArray (elementType) : c;
#endif
} else {
object c = Activator.CreateInstance (collectionType);
MethodInfo add = collectionType.GetMethod ("Add", new Type [] {elementType});
if (add == null) {
var icoll = typeof (ICollection<>).MakeGenericType (elementType);
if (icoll.IsAssignableFrom (c.GetType ()))
add = icoll.GetMethod ("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 elem = ReadObject (elementType);
add.Invoke (c, new object [] {elem});
}
ret = c;
}
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));
}
}
}