Files
mono/mcs/class/System.Web.Extensions/System.Web.Script.Serialization/JavaScriptSerializer.cs
T
Marek Habersack b68b65ad17 2009-08-18 Marek Habersack <[email protected]>
* Makefile (TEST_RESOURCE_FILES): added
	Test/mainsoft/NunitWebResources/DuplicateControlsInClientComment.aspx

2009-08-18  Marek Habersack  <[email protected]>

	* ControlBuilder.cs: Location property makes a copy of assigned
	ILocation now.

2009-08-18  Marek Habersack  <[email protected]>

	* AspParser.cs: added a constructor which creates an internal
	parser, nested within the outer one, and adjusts its ILocation
	members to report correct locations in the outer parser for better
	error reporting. Inner parser also returns the outer's FileText,
	if available.

	* AspGenerator.cs: restored part of r138474 reverted in r138657,
	r138658 and r138659 to fix bug #525104
	BuilderLocation creates a copy of Location for its own use (since
	the ILocation passed is actually AspParser, the line numbers
	change between creating a BuilderLocation and using its Location
	member).
	The end of tag, expression and client comment regular expressions
	now use lazy quantifiers. This fixes bugs #525104 and #517656
	Client side comment blocks aren't ignored anymore, they are parsed
	just as the other parts of the document. Fixes bug #524358

2009-08-18  Marek Habersack  <[email protected]>

	* JavaScriptSerializer.cs: read converters from the config only if
	explicitly requested.

2009-08-18  Marek Habersack  <[email protected]>

	* TemplateControlCompilerTest.cs: added test for bug #525104 and
	improved test for bug #517656

svn path=/trunk/mcs/; revision=140161
2009-08-18 13:31:49 +00:00

434 lines
13 KiB
C#

//
// JavaScriptSerializer.cs
//
// Author:
// Konstantin Triger <[email protected]>
//
// (C) 2007 Mainsoft, Inc. http://www.mainsoft.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.Generic;
using System.Text;
using Newtonsoft.Json;
using System.IO;
using System.Collections;
using System.Reflection;
using Newtonsoft.Json.Utilities;
using System.ComponentModel;
using System.Configuration;
using System.Web.Configuration;
namespace System.Web.Script.Serialization
{
public class JavaScriptSerializer
{
internal const string SerializedTypeNameKey = "__type";
List<IEnumerable<JavaScriptConverter>> _converterList;
int _maxJsonLength;
int _recursionLimit;
JavaScriptTypeResolver _typeResolver;
internal static readonly JavaScriptSerializer DefaultSerializer = new JavaScriptSerializer (null, false);
public JavaScriptSerializer () : this (null, false)
{
}
public JavaScriptSerializer (JavaScriptTypeResolver resolver) : this (resolver, false)
{
}
internal JavaScriptSerializer (JavaScriptTypeResolver resolver, bool registerConverters)
{
_typeResolver = resolver;
ScriptingJsonSerializationSection section = (ScriptingJsonSerializationSection) ConfigurationManager.GetSection ("system.web.extensions/scripting/webServices/jsonSerialization");
if (section == null) {
#if NET_3_5
_maxJsonLength = 2097152;
#else
_maxJsonLength = 102400;
#endif
_recursionLimit = 100;
} else {
_maxJsonLength = section.MaxJsonLength;
_recursionLimit = section.RecursionLimit;
if (registerConverters) {
ConvertersCollection converters = section.Converters;
if (converters != null && converters.Count > 0) {
var cvtlist = new List <JavaScriptConverter> ();
Type type;
string typeName;
JavaScriptConverter jsc;
foreach (Converter cvt in converters) {
typeName = cvt != null ? cvt.Type : null;
if (typeName == null)
continue;
type = HttpApplication.LoadType (typeName, true);
if (type == null || !typeof (JavaScriptConverter).IsAssignableFrom (type))
continue;
jsc = Activator.CreateInstance (type) as JavaScriptConverter;
cvtlist.Add (jsc);
}
RegisterConverters (cvtlist);
}
}
}
}
public int MaxJsonLength {
get {
return _maxJsonLength;
}
set {
_maxJsonLength = value;
}
}
public int RecursionLimit {
get {
return _recursionLimit;
}
set {
_recursionLimit = value;
}
}
internal JavaScriptTypeResolver TypeResolver {
get { return _typeResolver; }
}
public T ConvertToType<T> (object obj) {
if (obj == null)
return default (T);
return (T) ConvertToType (typeof (T), obj);
}
internal object ConvertToType (Type type, object obj) {
if (obj == null)
return null;
if (obj is IDictionary<string, object>) {
if (type == null)
obj = EvaluateDictionary ((IDictionary<string, object>) obj);
else {
JavaScriptConverter converter = GetConverter (type);
if (converter != null)
return converter.Deserialize (
EvaluateDictionary ((IDictionary<string, object>) obj),
type, this);
}
return ConvertToObject ((IDictionary<string, object>) obj, type);
}
if (obj is ArrayList)
return ConvertToList ((ArrayList) obj, type);
if (type == null)
return obj;
Type sourceType = obj.GetType ();
if (type.IsAssignableFrom (sourceType))
return obj;
if (type.IsEnum)
if (obj is string)
return Enum.Parse (type, (string) obj, true);
else
return Enum.ToObject (type, obj);
TypeConverter c = TypeDescriptor.GetConverter (type);
if (c.CanConvertFrom (sourceType)) {
if (obj is string)
return c.ConvertFromInvariantString ((string) obj);
return c.ConvertFrom (obj);
}
/*
* Take care of the special case whereas in JSON an empty string ("") really means
* an empty value
* (see: https://bugzilla.novell.com/show_bug.cgi?id=328836)
*/
if ( (type.IsGenericType) && (type.GetGenericTypeDefinition() == typeof(Nullable<>)) )
{
string s = obj as String;
if (String.IsNullOrEmpty(s))
return null;
}
return Convert.ChangeType (obj, type);
}
public T Deserialize<T> (string input) {
return ConvertToType<T> (DeserializeObjectInternal(input));
}
static object Evaluate (object value) {
return Evaluate (value, false);
}
static object Evaluate (object value, bool convertListToArray) {
if (value is IDictionary<string, object>)
value = EvaluateDictionary ((IDictionary<string, object>) value, convertListToArray);
else if (value is ArrayList)
value = EvaluateList ((ArrayList) value, convertListToArray);
return value;
}
static object EvaluateList (ArrayList e) {
return EvaluateList (e, false);
}
static object EvaluateList (ArrayList e, bool convertListToArray) {
ArrayList list = new ArrayList ();
foreach (object value in e)
list.Add (Evaluate (value, convertListToArray));
return convertListToArray ? (object) list.ToArray () : list;
}
static IDictionary<string, object> EvaluateDictionary (IDictionary<string, object> dict) {
return EvaluateDictionary (dict, false);
}
static IDictionary<string, object> EvaluateDictionary (IDictionary<string, object> dict, bool convertListToArray) {
Dictionary<string, object> d = new Dictionary<string, object> (StringComparer.Ordinal);
foreach (KeyValuePair<string, object> entry in dict) {
d.Add (entry.Key, Evaluate (entry.Value, convertListToArray));
}
return d;
}
static readonly Type typeofObject = typeof(object);
static readonly Type typeofGenList = typeof (List<>);
object ConvertToList (ArrayList col, Type type) {
Type elementType = null;
if (type != null && type.HasElementType)
elementType = type.GetElementType ();
IList list;
if (type == null || type.IsArray || typeofObject == type || typeof (ArrayList).IsAssignableFrom (type))
list = new ArrayList ();
else if (ReflectionUtils.IsInstantiatableType (type))
// non-generic typed list
list = (IList) Activator.CreateInstance (type, true);
else if (ReflectionUtils.IsAssignable (type, typeofGenList)) {
if (type.IsGenericType) {
Type [] genArgs = type.GetGenericArguments ();
elementType = genArgs [0];
// generic list
list = (IList) Activator.CreateInstance (typeofGenList.MakeGenericType (genArgs));
} else
list = new ArrayList ();
} else
throw new InvalidOperationException (String.Format ("Deserializing list type '{0}' not supported.", type.GetType ().Name));
if (list.IsReadOnly) {
EvaluateList (col);
return list;
}
foreach (object value in col)
list.Add (ConvertToType (elementType, value));
if (type != null && type.IsArray)
list = ((ArrayList) list).ToArray (elementType);
return list;
}
object ConvertToObject (IDictionary<string, object> dict, Type type)
{
if (_typeResolver != null) {
if (dict.Keys.Contains(SerializedTypeNameKey)) {
// already Evaluated
type = _typeResolver.ResolveType ((string) dict [SerializedTypeNameKey]);
}
}
if (type.IsGenericType) {
if (type.GetGenericTypeDefinition ().IsAssignableFrom (typeof (IDictionary <,>))) {
Type[] arguments = type.GetGenericArguments ();
if (arguments == null || arguments.Length != 2 || (arguments [0] != typeof (object) && arguments [0] != typeof (string)))
throw new InvalidOperationException (
"Type '" + type + "' is not not supported for serialization/deserialization of a dictionary, keys must be strings or objects.");
if (type.IsAbstract) {
Type dictType = typeof (Dictionary <,>);
type = dictType.MakeGenericType (arguments [0], arguments [1]);
}
}
} else if (type.IsAssignableFrom (typeof (IDictionary)))
type = typeof (Dictionary <string, object>);
object target = Activator.CreateInstance (type, true);
foreach (KeyValuePair<string, object> entry in dict) {
object value = entry.Value;
if (target is IDictionary) {
Type valueType = ReflectionUtils.GetTypedDictionaryValueType (type);
if (value != null && valueType == typeof (System.Object))
valueType = value.GetType ();
((IDictionary) target).Add (entry.Key, ConvertToType (valueType, value));
continue;
}
MemberInfo [] memberCollection = type.GetMember (entry.Key, BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
if (memberCollection == null || memberCollection.Length == 0) {
//must evaluate value
Evaluate (value);
continue;
}
MemberInfo member = memberCollection [0];
if (!ReflectionUtils.CanSetMemberValue (member)) {
//must evaluate value
Evaluate (value);
continue;
}
Type memberType = ReflectionUtils.GetMemberUnderlyingType (member);
if (memberType.IsInterface) {
if (memberType.IsGenericType)
memberType = ResolveGenericInterfaceToType (memberType);
else
memberType = ResolveInterfaceToType (memberType);
if (memberType == null)
throw new InvalidOperationException ("Unable to deserialize a member, as its type is an unknown interface.");
}
ReflectionUtils.SetMemberValue (member, target, ConvertToType(memberType, value));
}
return target;
}
Type ResolveGenericInterfaceToType (Type type)
{
Type[] genericArgs = type.GetGenericArguments ();
if (ReflectionUtils.IsSubClass (type, typeof (IDictionary <,>)))
return typeof (Dictionary <,>).MakeGenericType (genericArgs);
if (ReflectionUtils.IsSubClass (type, typeof (IList <>)) ||
ReflectionUtils.IsSubClass (type, typeof (ICollection <>)) ||
ReflectionUtils.IsSubClass (type, typeof (IEnumerable <>))
)
return typeof (List <>).MakeGenericType (genericArgs);
if (ReflectionUtils.IsSubClass (type, typeof (IComparer <>)))
return typeof (Comparer <>).MakeGenericType (genericArgs);
if (ReflectionUtils.IsSubClass (type, typeof (IEqualityComparer <>)))
return typeof (EqualityComparer <>).MakeGenericType (genericArgs);
return null;
}
Type ResolveInterfaceToType (Type type)
{
if (typeof (IDictionary).IsAssignableFrom (type))
return typeof (Hashtable);
if (typeof (IList).IsAssignableFrom (type) ||
typeof (ICollection).IsAssignableFrom (type) ||
typeof (IEnumerable).IsAssignableFrom (type))
return typeof (ArrayList);
if (typeof (IComparer).IsAssignableFrom (type))
return typeof (Comparer);
return null;
}
public object DeserializeObject (string input) {
object obj = Evaluate (DeserializeObjectInternal (input), true);
IDictionary dictObj = obj as IDictionary;
if (dictObj != null && dictObj.Contains(SerializedTypeNameKey)){
if (_typeResolver == null) {
throw new ArgumentNullException ("resolver", "Must have a type resolver to deserialize an object that has an '__type' member");
}
obj = ConvertToType(null, obj);
}
return obj;
}
internal object DeserializeObjectInternal (string input) {
return Json.Deserialize (input, this);
}
internal object DeserializeObjectInternal (TextReader input) {
return Json.Deserialize (input, this);
}
public void RegisterConverters (IEnumerable<JavaScriptConverter> converters) {
if (converters == null)
throw new ArgumentNullException ("converters");
if (_converterList == null)
_converterList = new List<IEnumerable<JavaScriptConverter>> ();
_converterList.Add (converters);
}
internal JavaScriptConverter GetConverter (Type type) {
if (_converterList != null)
for (int i = 0; i < _converterList.Count; i++) {
foreach (JavaScriptConverter converter in _converterList [i])
foreach (Type supportedType in converter.SupportedTypes)
if (supportedType.IsAssignableFrom (type))
return converter;
}
return null;
}
public string Serialize (object obj) {
StringBuilder b = new StringBuilder ();
Serialize (obj, b);
return b.ToString ();
}
public void Serialize (object obj, StringBuilder output) {
Json.Serialize (obj, this, output);
}
internal void Serialize (object obj, TextWriter output) {
Json.Serialize (obj, this, output);
}
}
}