mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-16 17:10:20 -10:00
* JsonSerializer.cs: do not perform deep object serialization - it results in all kinds of problems (including too big size of the resulting string, recursion errors when two or more objects in the hierarchy hold a reference to some object) and is not what .NET code does. Property name is written only after it is determined if we're serializing the property or not. Entire object is serialized only if it's the object requested for serialization by calling code. 2008-08-22 Marek Habersack <[email protected]> * Test/System.Web.Script.Serialization/JavaScriptSerializerTest.cs: marked several of the JavaScriptSerializer tests as not working. Experiments show that the tests are invalid as they relay on behavior which is different to .NET's. * System.Web.Script.Serialization/JavaScriptSerializer.cs: GetConverter now checks whether the requested type is descendant from the type supported by teh converter. svn path=/trunk/mcs/; revision=111421
554 lines
17 KiB
C#
554 lines
17 KiB
C#
#region License
|
|
// Copyright (c) 2007 James Newton-King
|
|
// Copyright 2007 Konstantin Triger <[email protected]>
|
|
//
|
|
// 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.Text;
|
|
using System.IO;
|
|
using System.Collections;
|
|
using System.Reflection;
|
|
using System.ComponentModel;
|
|
using Newtonsoft.Json.Utilities;
|
|
using System.Web.Script.Serialization;
|
|
|
|
namespace Newtonsoft.Json
|
|
{
|
|
/// <summary>
|
|
/// Specifies reference loop handling options for the <see cref="JsonWriter"/>.
|
|
/// </summary>
|
|
enum ReferenceLoopHandling
|
|
{
|
|
/// <summary>
|
|
/// Throw a <see cref="JsonSerializationException"/> when a loop is encountered.
|
|
/// </summary>
|
|
Error = 0,
|
|
/// <summary>
|
|
/// Ignore loop references and do not serialize.
|
|
/// </summary>
|
|
Ignore = 1,
|
|
/// <summary>
|
|
/// Serialize loop references.
|
|
/// </summary>
|
|
Serialize = 2
|
|
}
|
|
|
|
/// <summary>
|
|
/// Serializes and deserializes objects into and from the Json format.
|
|
/// The <see cref="JsonSerializer"/> enables you to control how objects are encoded into Json.
|
|
/// </summary>
|
|
sealed class JsonSerializer
|
|
{
|
|
sealed internal class DeserializerLazyDictionary : JavaScriptSerializer.LazyDictionary
|
|
{
|
|
readonly JsonReader _reader;
|
|
readonly JsonSerializer _serializer;
|
|
IEnumerator<KeyValuePair<string, object>> _innerEnum;
|
|
object _firstValue;
|
|
public DeserializerLazyDictionary (JsonReader reader, JsonSerializer serializer) {
|
|
_reader = reader;
|
|
_serializer = serializer;
|
|
}
|
|
|
|
public object PeekFirst () {
|
|
if (_innerEnum != null)
|
|
throw new InvalidOperationException ("first already taken");
|
|
|
|
_innerEnum = _serializer.PopulateObject (_reader);
|
|
|
|
if (_innerEnum.MoveNext ())
|
|
_firstValue = _innerEnum.Current;
|
|
|
|
return _firstValue;
|
|
}
|
|
|
|
protected override IEnumerator<KeyValuePair<string, object>> GetEnumerator () {
|
|
if (_innerEnum == null)
|
|
_innerEnum = _serializer.PopulateObject (_reader);
|
|
|
|
if (_firstValue != null)
|
|
yield return (KeyValuePair<string, object>) _firstValue;
|
|
|
|
while (_innerEnum.MoveNext ())
|
|
yield return _innerEnum.Current;
|
|
}
|
|
}
|
|
|
|
sealed class SerializerLazyDictionary : JavaScriptSerializer.LazyDictionary
|
|
{
|
|
readonly object _source;
|
|
|
|
public SerializerLazyDictionary (object source) {
|
|
_source = source;
|
|
}
|
|
|
|
protected override IEnumerator<KeyValuePair<string, object>> GetEnumerator () {
|
|
KeyValuePair <string, object> kvpret;
|
|
|
|
foreach (MemberInfo member in ReflectionUtils.GetFieldsAndProperties (_source.GetType (), BindingFlags.Public | BindingFlags.Instance)) {
|
|
if (ReflectionUtils.CanReadMemberValue (member) && !member.IsDefined (typeof (ScriptIgnoreAttribute), true))
|
|
if (!ReflectionUtils.IsIndexedProperty (member)) {
|
|
// A temporary hack to prevent situations
|
|
// when a type member cannot be serialized
|
|
// for some reason (e.g. when serializing a
|
|
// CultureInfo for 'en-US', processing its
|
|
// Parent property which returns CultureInfo
|
|
// for 'en' - asking for the Calendar
|
|
// property value for that one will throw an
|
|
// exception). Until a better solution is
|
|
// devised, this has to stay in.
|
|
try {
|
|
kvpret = new KeyValuePair<string, object> (member.Name, ReflectionUtils.GetMemberValue (member, _source));
|
|
} catch (Exception ex) {
|
|
Console.Error.WriteLine ("HACK WARNING! NOT YIELDING THE VALUE! Serializing {0}.{1} threw an exception:", _source.GetType (), member.Name);
|
|
Console.Error.WriteLine (ex);
|
|
continue;
|
|
}
|
|
yield return kvpret;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
sealed class GenericDictionaryLazyDictionary : JavaScriptSerializer.LazyDictionary
|
|
{
|
|
readonly object _source;
|
|
readonly PropertyInfo _piKeys;
|
|
readonly PropertyInfo _piValues;
|
|
|
|
|
|
public GenericDictionaryLazyDictionary (object source, Type dictType) {
|
|
_source = source;
|
|
_piKeys = dictType.GetProperty ("Keys");
|
|
_piValues = dictType.GetProperty ("Values");
|
|
}
|
|
|
|
protected override IEnumerator<KeyValuePair<string, object>> GetEnumerator () {
|
|
|
|
IEnumerable eKeys = (IEnumerable) _piKeys.GetValue (_source, null);
|
|
IEnumerator eValues = ((IEnumerable) _piValues.GetValue (_source, null)).GetEnumerator();
|
|
foreach (object key in eKeys) {
|
|
string keyString = key == null ? null : key.ToString ();
|
|
if (!eValues.MoveNext ())
|
|
throw new IndexOutOfRangeException (keyString);
|
|
|
|
|
|
yield return new KeyValuePair<string, object> (keyString, eValues.Current);
|
|
}
|
|
|
|
if (eValues.MoveNext ())
|
|
throw new IndexOutOfRangeException (eValues.Current != null ? eValues.Current.ToString () : String.Empty);
|
|
}
|
|
}
|
|
|
|
private int _maxJsonLength;
|
|
private int _recursionLimit;
|
|
private int _currentRecursionCounter;
|
|
private ReferenceLoopHandling _referenceLoopHandling;
|
|
readonly JavaScriptSerializer _context;
|
|
readonly JavaScriptTypeResolver _typeResolver;
|
|
|
|
public int MaxJsonLength
|
|
{
|
|
get { return _maxJsonLength; }
|
|
set { _maxJsonLength = value; }
|
|
}
|
|
|
|
public int RecursionLimit {
|
|
get { return _recursionLimit; }
|
|
set { _recursionLimit = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get or set how reference loops (e.g. a class referencing itself) is handled.
|
|
/// </summary>
|
|
public ReferenceLoopHandling ReferenceLoopHandling
|
|
{
|
|
get { return _referenceLoopHandling; }
|
|
set
|
|
{
|
|
if (value < ReferenceLoopHandling.Error || value > ReferenceLoopHandling.Serialize)
|
|
{
|
|
throw new ArgumentOutOfRangeException("value");
|
|
}
|
|
_referenceLoopHandling = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="JsonSerializer"/> class.
|
|
/// </summary>
|
|
public JsonSerializer(JavaScriptSerializer context, JavaScriptTypeResolver resolver)
|
|
{
|
|
_context = context;
|
|
_typeResolver = resolver;
|
|
_referenceLoopHandling = ReferenceLoopHandling.Error;
|
|
}
|
|
|
|
#region Deserialize
|
|
public object Deserialize (TextReader reader) {
|
|
return Deserialize (new JsonReader (reader, MaxJsonLength, RecursionLimit));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deserializes the Json structure contained by the specified <see cref="JsonReader"/>
|
|
/// into an instance of the specified type.
|
|
/// </summary>
|
|
/// <param name="reader">The type of object to create.</param>
|
|
/// <param name="objectType">The <see cref="Type"/> of object being deserialized.</param>
|
|
/// <returns>The instance of <paramref name="objectType"/> being deserialized.</returns>
|
|
object Deserialize (JsonReader reader)
|
|
{
|
|
if (!reader.Read())
|
|
return null;
|
|
|
|
return GetObject(reader);
|
|
}
|
|
|
|
private object GetObject (JsonReader reader/*, Type objectType*/) {
|
|
if (RecursionLimit > 0 && reader.CurrentRecursionLevel >= RecursionLimit) {
|
|
throw new ArgumentException ("RecursionLimit exceeded.");
|
|
}
|
|
|
|
object value;
|
|
|
|
switch (reader.TokenType) {
|
|
// populate a typed object or generic dictionary/array
|
|
// depending upon whether an objectType was supplied
|
|
case JsonToken.StartObject:
|
|
//value = PopulateObject(reader/*, objectType*/);
|
|
value = new DeserializerLazyDictionary (reader, this);
|
|
break;
|
|
case JsonToken.StartArray:
|
|
value = PopulateList (reader/*, objectType*/);
|
|
break;
|
|
case JsonToken.Integer:
|
|
case JsonToken.Float:
|
|
case JsonToken.String:
|
|
case JsonToken.Boolean:
|
|
case JsonToken.Date:
|
|
//value = EnsureType(reader.Value, objectType);
|
|
value = reader.Value;
|
|
break;
|
|
case JsonToken.Constructor:
|
|
value = reader.Value.ToString ();
|
|
break;
|
|
case JsonToken.Null:
|
|
case JsonToken.Undefined:
|
|
value = null;
|
|
break;
|
|
default:
|
|
throw new JsonSerializationException ("Unexpected token whil deserializing object: " + reader.TokenType);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
private IEnumerable<object> PopulateList(JsonReader reader/*, Type objectType*/)
|
|
{
|
|
|
|
while (reader.Read())
|
|
{
|
|
switch (reader.TokenType)
|
|
{
|
|
case JsonToken.EndArray:
|
|
yield break;
|
|
case JsonToken.Comment:
|
|
break;
|
|
default:
|
|
yield return GetObject(reader/*, elementType*/);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
throw new JsonSerializationException("Unexpected end when deserializing array.");
|
|
}
|
|
|
|
private IEnumerator<KeyValuePair<string, object>> PopulateObject (JsonReader reader/*, Type objectType*/)
|
|
{
|
|
reader.IncrementRecursionLevel ();
|
|
while (reader.Read ())
|
|
{
|
|
switch (reader.TokenType)
|
|
{
|
|
case JsonToken.PropertyName:
|
|
string memberName = reader.Value.ToString();
|
|
|
|
if (!reader.Read ())
|
|
throw new JsonSerializationException (string.Format ("Unexpected end when setting {0}'s value.", memberName));
|
|
yield return new KeyValuePair<string, object> (memberName, GetObject (reader));
|
|
break;
|
|
case JsonToken.EndObject:
|
|
reader.DecrementRecursionLevel ();
|
|
yield break;
|
|
default:
|
|
throw new JsonSerializationException("Unexpected token when deserializing object: " + reader.TokenType);
|
|
}
|
|
}
|
|
|
|
throw new JsonSerializationException("Unexpected end when deserializing object.");
|
|
}
|
|
#endregion
|
|
|
|
#region Serialize
|
|
/// <summary>
|
|
/// Serializes the specified <see cref="Object"/> and writes the Json structure
|
|
/// to a <c>Stream</c> using the specified <see cref="TextWriter"/>.
|
|
/// </summary>
|
|
/// <param name="textWriter">The <see cref="TextWriter"/> used to write the Json structure.</param>
|
|
/// <param name="value">The <see cref="Object"/> to serialize.</param>
|
|
public void Serialize(TextWriter textWriter, object value)
|
|
{
|
|
Serialize(new JsonWriter(textWriter, MaxJsonLength), value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Serializes the specified <see cref="Object"/> and writes the Json structure
|
|
/// to a <c>Stream</c> using the specified <see cref="JsonWriter"/>.
|
|
/// </summary>
|
|
/// <param name="jsonWriter">The <see cref="JsonWriter"/> used to write the Json structure.</param>
|
|
/// <param name="value">The <see cref="Object"/> to serialize.</param>
|
|
void Serialize(JsonWriter jsonWriter, object value)
|
|
{
|
|
SerializeValue (jsonWriter, value, true, null);
|
|
}
|
|
|
|
|
|
private void SerializeValue(JsonWriter writer, object value)
|
|
{
|
|
SerializeValue (writer, value, false, null);
|
|
}
|
|
|
|
private void WritePropertyName (JsonWriter writer, string name)
|
|
{
|
|
if (String.IsNullOrEmpty (name))
|
|
return;
|
|
|
|
writer.WritePropertyName (name);
|
|
}
|
|
|
|
private void SerializeValue (JsonWriter writer, object value, bool topLevelObject, string propertyName)
|
|
{
|
|
//JsonConverter converter;
|
|
_currentRecursionCounter++;
|
|
if (RecursionLimit > 0 && _currentRecursionCounter > RecursionLimit) {
|
|
throw new ArgumentException ("RecursionLimit exceeded.");
|
|
}
|
|
|
|
if (value == null) {
|
|
WritePropertyName (writer, propertyName);
|
|
writer.WriteNull ();
|
|
}
|
|
else {
|
|
Type valueType = value.GetType ();
|
|
JavaScriptConverter jsconverter = _context.GetConverter (valueType);
|
|
if (jsconverter != null) {
|
|
value = jsconverter.Serialize (value, _context);
|
|
if (value == null) {
|
|
WritePropertyName (writer, propertyName);
|
|
writer.WriteNull ();
|
|
_currentRecursionCounter--;
|
|
return;
|
|
}
|
|
}
|
|
|
|
switch (Type.GetTypeCode (valueType)) {
|
|
case TypeCode.String:
|
|
WritePropertyName (writer, propertyName);
|
|
writer.WriteValue ((string) value);
|
|
break;
|
|
case TypeCode.Char:
|
|
WritePropertyName (writer, propertyName);
|
|
writer.WriteValue ((char) value);
|
|
break;
|
|
case TypeCode.Boolean:
|
|
WritePropertyName (writer, propertyName);
|
|
writer.WriteValue ((bool) value);
|
|
break;
|
|
case TypeCode.SByte:
|
|
WritePropertyName (writer, propertyName);
|
|
writer.WriteValue ((sbyte) value);
|
|
break;
|
|
case TypeCode.Int16:
|
|
WritePropertyName (writer, propertyName);
|
|
writer.WriteValue ((short) value);
|
|
break;
|
|
case TypeCode.UInt16:
|
|
WritePropertyName (writer, propertyName);
|
|
writer.WriteValue ((ushort) value);
|
|
break;
|
|
case TypeCode.Int32:
|
|
WritePropertyName (writer, propertyName);
|
|
writer.WriteValue ((int) value);
|
|
break;
|
|
case TypeCode.Byte:
|
|
WritePropertyName (writer, propertyName);
|
|
writer.WriteValue ((byte) value);
|
|
break;
|
|
case TypeCode.UInt32:
|
|
WritePropertyName (writer, propertyName);
|
|
writer.WriteValue ((uint) value);
|
|
break;
|
|
case TypeCode.Int64:
|
|
WritePropertyName (writer, propertyName);
|
|
writer.WriteValue ((long) value);
|
|
break;
|
|
case TypeCode.UInt64:
|
|
WritePropertyName (writer, propertyName);
|
|
writer.WriteValue ((ulong) value);
|
|
break;
|
|
case TypeCode.Single:
|
|
WritePropertyName (writer, propertyName);
|
|
writer.WriteValue ((float) value);
|
|
break;
|
|
case TypeCode.Double:
|
|
WritePropertyName (writer, propertyName);
|
|
writer.WriteValue ((double) value);
|
|
break;
|
|
case TypeCode.DateTime:
|
|
WritePropertyName (writer, propertyName);
|
|
writer.WriteValue ((DateTime) value);
|
|
break;
|
|
case TypeCode.Decimal:
|
|
WritePropertyName (writer, propertyName);
|
|
writer.WriteValue ((decimal) value);
|
|
break;
|
|
default:
|
|
|
|
ThrowOnReferenceLoop (writer, value);
|
|
writer.SerializeStack.Push (value);
|
|
try {
|
|
Type genDictType;
|
|
if (value is IDictionary) {
|
|
WritePropertyName (writer, propertyName);
|
|
SerializeDictionary (writer, (IDictionary) value);
|
|
} else if (value is IDictionary<string, object>) {
|
|
WritePropertyName (writer, propertyName);
|
|
SerializeDictionary (writer, (IDictionary<string, object>) value, null);
|
|
} else if ((genDictType = ReflectionUtils.GetGenericDictionary (valueType)) != null) {
|
|
WritePropertyName (writer, propertyName);
|
|
SerializeDictionary (writer, new GenericDictionaryLazyDictionary (value, genDictType), null);
|
|
} else if (value is IEnumerable) {
|
|
WritePropertyName (writer, propertyName);
|
|
SerializeEnumerable (writer, (IEnumerable) value);
|
|
} else if (topLevelObject) {
|
|
SerializeCustomObject (writer, value, valueType);
|
|
}
|
|
}
|
|
finally {
|
|
|
|
object x = writer.SerializeStack.Pop ();
|
|
if (x != value)
|
|
throw new InvalidOperationException ("Serialization stack is corrupted");
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
_currentRecursionCounter--;
|
|
}
|
|
|
|
private void ThrowOnReferenceLoop (JsonWriter writer, object value)
|
|
{
|
|
switch (_referenceLoopHandling) {
|
|
case ReferenceLoopHandling.Error:
|
|
if (writer.SerializeStack.Contains (value))
|
|
throw new JsonSerializationException ("Self referencing loop");
|
|
break;
|
|
case ReferenceLoopHandling.Ignore:
|
|
// return from method
|
|
return;
|
|
case ReferenceLoopHandling.Serialize:
|
|
// continue
|
|
break;
|
|
default:
|
|
throw new InvalidOperationException (string.Format ("Unexpected ReferenceLoopHandling value: '{0}'", _referenceLoopHandling));
|
|
}
|
|
}
|
|
|
|
private void SerializeEnumerable (JsonWriter writer, IEnumerable values) {
|
|
writer.WriteStartArray ();
|
|
|
|
foreach (object value in values)
|
|
SerializeValue (writer, value);
|
|
|
|
writer.WriteEndArray ();
|
|
}
|
|
|
|
private void SerializeDictionary(JsonWriter writer, IDictionary values)
|
|
{
|
|
writer.WriteStartObject();
|
|
|
|
foreach (DictionaryEntry entry in values)
|
|
SerializePair (writer, entry.Key.ToString (), entry.Value);
|
|
|
|
writer.WriteEndObject();
|
|
}
|
|
|
|
private void SerializeDictionary (JsonWriter writer, IDictionary<string, object> values, string typeID) {
|
|
|
|
writer.WriteStartObject ();
|
|
|
|
if (typeID != null) {
|
|
SerializePair (writer, JavaScriptSerializer.SerializedTypeNameKey, typeID);
|
|
}
|
|
|
|
foreach (KeyValuePair<string, object> entry in values)
|
|
SerializePair (writer, entry.Key, entry.Value);
|
|
|
|
writer.WriteEndObject ();
|
|
}
|
|
|
|
private void SerializeCustomObject (JsonWriter writer, object value, Type valueType)
|
|
{
|
|
if (value is Uri) {
|
|
Uri uri = value as Uri;
|
|
writer.WriteValue (uri.GetComponents (UriComponents.AbsoluteUri, UriFormat.UriEscaped));
|
|
return;
|
|
}
|
|
if (valueType == typeof (Guid)) {
|
|
writer.WriteValue (((Guid) value).ToString ());
|
|
return;
|
|
}
|
|
|
|
string typeID = null;
|
|
if (_typeResolver != null) {
|
|
typeID = _typeResolver.ResolveTypeId (valueType);
|
|
}
|
|
|
|
SerializeDictionary (writer, new SerializerLazyDictionary (value), typeID);
|
|
}
|
|
|
|
private void SerializePair (JsonWriter writer, string key, object value) {
|
|
SerializeValue (writer, value, false, key);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|