mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
540 lines
23 KiB
C#
540 lines
23 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="JavaScriptSerializer.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.Script.Serialization {
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Globalization;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Web;
|
|
using System.Web.Resources;
|
|
|
|
public class JavaScriptSerializer {
|
|
internal const string ServerTypeFieldName = "__type";
|
|
internal const int DefaultRecursionLimit = 100;
|
|
internal const int DefaultMaxJsonLength = 2097152;
|
|
|
|
internal static string SerializeInternal(object o) {
|
|
JavaScriptSerializer serializer = new JavaScriptSerializer();
|
|
return serializer.Serialize(o);
|
|
}
|
|
|
|
internal static object Deserialize(JavaScriptSerializer serializer, string input, Type type, int depthLimit) {
|
|
if (input == null) {
|
|
throw new ArgumentNullException("input");
|
|
}
|
|
if (input.Length > serializer.MaxJsonLength) {
|
|
throw new ArgumentException(AtlasWeb.JSON_MaxJsonLengthExceeded, "input");
|
|
}
|
|
|
|
object o = JavaScriptObjectDeserializer.BasicDeserialize(input, depthLimit, serializer);
|
|
return ObjectConverter.ConvertObjectToType(o, type, serializer);
|
|
}
|
|
|
|
// INSTANCE fields/methods
|
|
private JavaScriptTypeResolver _typeResolver;
|
|
private int _recursionLimit;
|
|
private int _maxJsonLength;
|
|
|
|
public JavaScriptSerializer() : this(null) { }
|
|
|
|
public JavaScriptSerializer(JavaScriptTypeResolver resolver) {
|
|
_typeResolver = resolver;
|
|
RecursionLimit = DefaultRecursionLimit;
|
|
MaxJsonLength = DefaultMaxJsonLength;
|
|
}
|
|
|
|
public int MaxJsonLength {
|
|
get {
|
|
return _maxJsonLength;
|
|
}
|
|
set {
|
|
if (value < 1) {
|
|
throw new ArgumentOutOfRangeException(AtlasWeb.JSON_InvalidMaxJsonLength);
|
|
}
|
|
_maxJsonLength = value;
|
|
}
|
|
}
|
|
|
|
public int RecursionLimit {
|
|
get {
|
|
return _recursionLimit;
|
|
}
|
|
set {
|
|
if (value < 1) {
|
|
throw new ArgumentOutOfRangeException(AtlasWeb.JSON_InvalidRecursionLimit);
|
|
}
|
|
_recursionLimit = value;
|
|
}
|
|
}
|
|
|
|
internal JavaScriptTypeResolver TypeResolver {
|
|
get {
|
|
return _typeResolver;
|
|
}
|
|
}
|
|
|
|
private Dictionary<Type, JavaScriptConverter> _converters;
|
|
private Dictionary<Type, JavaScriptConverter> Converters {
|
|
get {
|
|
if (_converters == null) {
|
|
_converters = new Dictionary<Type, JavaScriptConverter>();
|
|
}
|
|
return _converters;
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Usage", "CA2301:EmbeddableTypesInContainersRule", MessageId = "Converters", Justification = "This is for managed types which need to have custom type converters for JSon serialization, I don't think there will be any com interop types for this scenario.")]
|
|
public void RegisterConverters(IEnumerable<JavaScriptConverter> converters)
|
|
{
|
|
if (converters == null) {
|
|
throw new ArgumentNullException("converters");
|
|
}
|
|
|
|
foreach (JavaScriptConverter converter in converters) {
|
|
IEnumerable<Type> supportedTypes = converter.SupportedTypes;
|
|
if (supportedTypes != null) {
|
|
foreach (Type supportedType in supportedTypes) {
|
|
Converters[supportedType] = converter;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Usage", "CA2301:EmbeddableTypesInContainersRule", MessageId = "_converters", Justification = "This is for managed types which need to have custom type converters for JSon serialization, I don't think there will be any com interop types for this scenario.")]
|
|
private JavaScriptConverter GetConverter(Type t)
|
|
{
|
|
if (_converters != null) {
|
|
while (t != null) {
|
|
if (_converters.ContainsKey(t)) {
|
|
return _converters[t];
|
|
}
|
|
t = t.BaseType;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
internal bool ConverterExistsForType(Type t, out JavaScriptConverter converter) {
|
|
converter = GetConverter(t);
|
|
return converter != null;
|
|
}
|
|
|
|
public object DeserializeObject(string input) {
|
|
return Deserialize(this, input, null /*type*/, RecursionLimit);
|
|
}
|
|
|
|
[
|
|
SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter",
|
|
Justification = "Generic parameter is preferable to forcing caller to downcast. " +
|
|
"Has has been approved by API review board. " +
|
|
"Dev10 701126: Overload added afterall, to allow runtime determination of the type.")
|
|
]
|
|
public T Deserialize<T>(string input) {
|
|
return (T)Deserialize(this, input, typeof(T), RecursionLimit);
|
|
}
|
|
|
|
public object Deserialize(string input, Type targetType) {
|
|
return Deserialize(this, input, targetType, RecursionLimit);
|
|
}
|
|
|
|
[
|
|
SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter",
|
|
Justification = "Generic parameter is preferable to forcing caller to downcast. " +
|
|
"Has has been approved by API review board. " +
|
|
"Dev10 701126: Overload added afterall, to allow runtime determination of the type."),
|
|
SuppressMessage("Microsoft.Naming", "CA1720:IdentifiersShouldNotContainTypeNames", MessageId = "obj",
|
|
Justification = "Cannot change parameter name as would break binary compatibility with legacy apps.")
|
|
]
|
|
public T ConvertToType<T>(object obj) {
|
|
return (T)ObjectConverter.ConvertObjectToType(obj, typeof(T), this);
|
|
}
|
|
|
|
[
|
|
SuppressMessage("Microsoft.Naming", "CA1720:IdentifiersShouldNotContainTypeNames", MessageId = "obj",
|
|
Justification = "Consistent with previously existing overload which cannot be changed.")
|
|
]
|
|
public object ConvertToType(object obj, Type targetType) {
|
|
return ObjectConverter.ConvertObjectToType(obj, targetType, this);
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Naming", "CA1720:IdentifiersShouldNotContainTypeNames", MessageId = "obj",
|
|
Justification = "Cannot change parameter name as would break binary compatibility with legacy apps.")]
|
|
public string Serialize(object obj) {
|
|
return Serialize(obj, SerializationFormat.JSON);
|
|
}
|
|
|
|
internal string Serialize(object obj, SerializationFormat serializationFormat) {
|
|
StringBuilder sb = new StringBuilder();
|
|
Serialize(obj, sb, serializationFormat);
|
|
return sb.ToString();
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Naming", "CA1720:IdentifiersShouldNotContainTypeNames", MessageId = "obj",
|
|
Justification = "Cannot change parameter name as would break binary compatibility with legacy apps.")]
|
|
public void Serialize(object obj, StringBuilder output) {
|
|
Serialize(obj, output, SerializationFormat.JSON);
|
|
}
|
|
|
|
internal void Serialize(object obj, StringBuilder output, SerializationFormat serializationFormat) {
|
|
SerializeValue(obj, output, 0, null, serializationFormat);
|
|
// DevDiv Bugs 96574: Max JSON length does not apply when serializing to Javascript for ScriptDescriptors
|
|
if (serializationFormat == SerializationFormat.JSON && output.Length > MaxJsonLength) {
|
|
throw new InvalidOperationException(AtlasWeb.JSON_MaxJsonLengthExceeded);
|
|
}
|
|
}
|
|
|
|
private static void SerializeBoolean(bool o, StringBuilder sb) {
|
|
if (o) {
|
|
sb.Append("true");
|
|
}
|
|
else {
|
|
sb.Append("false");
|
|
}
|
|
}
|
|
|
|
private static void SerializeUri(Uri uri, StringBuilder sb) {
|
|
sb.Append("\"").Append(uri.GetComponents(UriComponents.SerializationInfoString, UriFormat.UriEscaped)).Append("\"");
|
|
}
|
|
|
|
private static void SerializeGuid(Guid guid, StringBuilder sb) {
|
|
sb.Append("\"").Append(guid.ToString()).Append("\"");
|
|
}
|
|
|
|
internal static readonly long DatetimeMinTimeTicks = (new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).Ticks;
|
|
private static void SerializeDateTime(DateTime datetime, StringBuilder sb, SerializationFormat serializationFormat) {
|
|
Debug.Assert(serializationFormat == SerializationFormat.JSON || serializationFormat == SerializationFormat.JavaScript);
|
|
if (serializationFormat == SerializationFormat.JSON) {
|
|
// DevDiv 41127: Never confuse atlas serialized strings with dates
|
|
// Serialized date: "\/Date(123)\/"
|
|
sb.Append(@"""\/Date(");
|
|
sb.Append((datetime.ToUniversalTime().Ticks - DatetimeMinTimeTicks) / 10000);
|
|
sb.Append(@")\/""");
|
|
}
|
|
else {
|
|
// DevDiv 96574: Need to be able to serialize to javascript dates for script descriptors
|
|
// new Date(ticks)
|
|
sb.Append("new Date(");
|
|
sb.Append((datetime.ToUniversalTime().Ticks - DatetimeMinTimeTicks) / 10000);
|
|
sb.Append(@")");
|
|
}
|
|
}
|
|
|
|
// Serialize custom object graph
|
|
private void SerializeCustomObject(object o, StringBuilder sb, int depth, Hashtable objectsInUse, SerializationFormat serializationFormat) {
|
|
bool first = true;
|
|
Type type = o.GetType();
|
|
sb.Append('{');
|
|
|
|
// Serialize the object type if we have a type resolver
|
|
if (TypeResolver != null) {
|
|
|
|
// Only do this if the context is actually aware of this type
|
|
string typeString = TypeResolver.ResolveTypeId(type);
|
|
if (typeString != null) {
|
|
SerializeString(ServerTypeFieldName, sb);
|
|
sb.Append(':');
|
|
SerializeValue(typeString, sb, depth, objectsInUse, serializationFormat);
|
|
first = false;
|
|
}
|
|
}
|
|
|
|
FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.Instance);
|
|
foreach (FieldInfo fieldInfo in fields) {
|
|
|
|
// Ignore all fields marked as [ScriptIgnore]
|
|
if (CheckScriptIgnoreAttribute(fieldInfo)) {
|
|
continue;
|
|
}
|
|
|
|
if (!first) sb.Append(',');
|
|
SerializeString(fieldInfo.Name, sb);
|
|
sb.Append(':');
|
|
SerializeValue(SecurityUtils.FieldInfoGetValue(fieldInfo, o), sb, depth, objectsInUse, serializationFormat, currentMember: fieldInfo);
|
|
first = false;
|
|
}
|
|
|
|
PropertyInfo[] props = type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.GetProperty);
|
|
foreach (PropertyInfo propInfo in props) {
|
|
|
|
// Ignore all properties marked as [ScriptIgnore]
|
|
if (CheckScriptIgnoreAttribute(propInfo))
|
|
continue;
|
|
|
|
MethodInfo getMethodInfo = propInfo.GetGetMethod();
|
|
|
|
// Skip property if it has no get
|
|
if (getMethodInfo == null) {
|
|
continue;
|
|
}
|
|
|
|
// Ignore indexed properties
|
|
if (getMethodInfo.GetParameters().Length > 0) continue;
|
|
|
|
if (!first) sb.Append(',');
|
|
SerializeString(propInfo.Name, sb);
|
|
sb.Append(':');
|
|
SerializeValue(SecurityUtils.MethodInfoInvoke(getMethodInfo, o, null), sb, depth, objectsInUse, serializationFormat, currentMember: propInfo);
|
|
first = false;
|
|
}
|
|
|
|
sb.Append('}');
|
|
}
|
|
|
|
private bool CheckScriptIgnoreAttribute(MemberInfo memberInfo) {
|
|
// Ignore all members marked as [ScriptIgnore]
|
|
if (memberInfo.IsDefined(typeof(ScriptIgnoreAttribute), true /*inherits*/)) return true;
|
|
|
|
//The above API does not consider the inherit boolean and the right API for that is Attribute.IsDefined.
|
|
//However, to keep the backward compatibility with 4.0, we decided to define an opt-in mechanism (ApplyToOverrides property on ScriptIgnoreAttribute)
|
|
//to consider the inherit boolean.
|
|
ScriptIgnoreAttribute scriptIgnoreAttr = (ScriptIgnoreAttribute)Attribute.GetCustomAttribute(memberInfo, typeof(ScriptIgnoreAttribute), inherit: true);
|
|
if (scriptIgnoreAttr != null && scriptIgnoreAttr.ApplyToOverrides) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private void SerializeDictionary(IDictionary o, StringBuilder sb, int depth, Hashtable objectsInUse, SerializationFormat serializationFormat) {
|
|
sb.Append('{');
|
|
bool isFirstElement = true;
|
|
bool isTypeEntrySet = false;
|
|
|
|
//make sure __type field is the first to be serialized if it exists
|
|
if (o.Contains(ServerTypeFieldName)) {
|
|
isFirstElement = false;
|
|
isTypeEntrySet = true;
|
|
SerializeDictionaryKeyValue(ServerTypeFieldName, o[ServerTypeFieldName], sb, depth, objectsInUse, serializationFormat);
|
|
}
|
|
|
|
foreach (DictionaryEntry entry in (IDictionary)o) {
|
|
|
|
string key = entry.Key as string;
|
|
if (key == null) {
|
|
throw new ArgumentException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.JSON_DictionaryTypeNotSupported, o.GetType().FullName));
|
|
}
|
|
if (isTypeEntrySet && String.Equals(key, ServerTypeFieldName, StringComparison.Ordinal)) {
|
|
// The dictionay only contains max one entry for __type key, and it has been iterated
|
|
// through, so don't need to check for is anymore.
|
|
isTypeEntrySet = false;
|
|
continue;
|
|
}
|
|
if (!isFirstElement) {
|
|
sb.Append(',');
|
|
}
|
|
SerializeDictionaryKeyValue(key, entry.Value, sb, depth, objectsInUse, serializationFormat);
|
|
isFirstElement = false;
|
|
}
|
|
sb.Append('}');
|
|
}
|
|
|
|
private void SerializeDictionaryKeyValue(string key, object value, StringBuilder sb, int depth, Hashtable objectsInUse, SerializationFormat serializationFormat) {
|
|
|
|
SerializeString(key, sb);
|
|
sb.Append(':');
|
|
SerializeValue(value, sb, depth, objectsInUse, serializationFormat);
|
|
}
|
|
|
|
private void SerializeEnumerable(IEnumerable enumerable, StringBuilder sb, int depth, Hashtable objectsInUse, SerializationFormat serializationFormat) {
|
|
sb.Append('[');
|
|
bool isFirstElement = true;
|
|
foreach (object o in enumerable) {
|
|
if (!isFirstElement) {
|
|
sb.Append(',');
|
|
}
|
|
|
|
SerializeValue(o, sb, depth, objectsInUse, serializationFormat);
|
|
isFirstElement = false;
|
|
}
|
|
sb.Append(']');
|
|
}
|
|
|
|
private static void SerializeString(string input, StringBuilder sb) {
|
|
sb.Append('"');
|
|
sb.Append(HttpUtility.JavaScriptStringEncode(input));
|
|
sb.Append('"');
|
|
}
|
|
|
|
private void SerializeValue(object o, StringBuilder sb, int depth, Hashtable objectsInUse, SerializationFormat serializationFormat, MemberInfo currentMember = null) {
|
|
if (++depth > _recursionLimit) {
|
|
throw new ArgumentException(AtlasWeb.JSON_DepthLimitExceeded);
|
|
}
|
|
|
|
// Check whether a custom converter is available for this type.
|
|
JavaScriptConverter converter = null;
|
|
if (o != null && ConverterExistsForType(o.GetType(), out converter)) {
|
|
IDictionary<string, object> dict = converter.Serialize(o, this);
|
|
|
|
if (TypeResolver != null) {
|
|
string typeString = TypeResolver.ResolveTypeId(o.GetType());
|
|
if (typeString != null) {
|
|
dict[ServerTypeFieldName] = typeString;
|
|
}
|
|
}
|
|
|
|
sb.Append(Serialize(dict, serializationFormat));
|
|
return;
|
|
}
|
|
|
|
SerializeValueInternal(o, sb, depth, objectsInUse, serializationFormat, currentMember);
|
|
}
|
|
|
|
// We use this for our cycle detection for the case where objects override equals/gethashcode
|
|
private class ReferenceComparer : IEqualityComparer {
|
|
bool IEqualityComparer.Equals(object x, object y) {
|
|
return x == y;
|
|
}
|
|
|
|
int IEqualityComparer.GetHashCode(object obj) {
|
|
return System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);
|
|
}
|
|
}
|
|
|
|
private void SerializeValueInternal(object o, StringBuilder sb, int depth, Hashtable objectsInUse, SerializationFormat serializationFormat, MemberInfo currentMember) {
|
|
// 'null' is a special JavaScript token
|
|
if (o == null || DBNull.Value.Equals(o)) {
|
|
sb.Append("null");
|
|
return;
|
|
}
|
|
|
|
// Strings and chars are represented as quoted (single or double) in Javascript.
|
|
string os = o as String;
|
|
if (os != null) {
|
|
SerializeString(os, sb);
|
|
return;
|
|
}
|
|
|
|
if (o is Char) {
|
|
// Special case the null char as we don't want it to turn into a null string
|
|
if ((char)o == '\0') {
|
|
sb.Append("null");
|
|
return;
|
|
}
|
|
SerializeString(o.ToString(), sb);
|
|
return;
|
|
}
|
|
|
|
// Bools are represented as 'true' and 'false' (no quotes) in Javascript.
|
|
if (o is bool) {
|
|
SerializeBoolean((bool)o, sb);
|
|
return;
|
|
}
|
|
|
|
if (o is DateTime) {
|
|
SerializeDateTime((DateTime)o, sb, serializationFormat);
|
|
return;
|
|
}
|
|
|
|
if (o is DateTimeOffset) {
|
|
// DateTimeOffset is converted to a UTC DateTime and serialized as usual.
|
|
SerializeDateTime(((DateTimeOffset)o).UtcDateTime, sb, serializationFormat);
|
|
return;
|
|
}
|
|
|
|
if (o is Guid) {
|
|
SerializeGuid((Guid)o, sb);
|
|
return;
|
|
}
|
|
|
|
Uri uri = o as Uri;
|
|
if (uri != null) {
|
|
SerializeUri(uri, sb);
|
|
return;
|
|
}
|
|
|
|
// Have to special case floats to get full precision
|
|
if (o is double) {
|
|
sb.Append(((double)o).ToString("r", CultureInfo.InvariantCulture));
|
|
return;
|
|
}
|
|
|
|
if (o is float) {
|
|
sb.Append(((float)o).ToString("r", CultureInfo.InvariantCulture));
|
|
return;
|
|
}
|
|
|
|
// Deal with any server type that can be represented as a number in JavaScript
|
|
if (o.GetType().IsPrimitive || o is Decimal) {
|
|
IConvertible convertible = o as IConvertible;
|
|
if (convertible != null) {
|
|
sb.Append(convertible.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
else {
|
|
// In theory, all primitive types implement IConvertible
|
|
Debug.Assert(false);
|
|
sb.Append(o.ToString());
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Serialize enums as their integer value
|
|
Type type = o.GetType();
|
|
if (type.IsEnum) {
|
|
// Int64 and UInt64 result in numbers too big for JavaScript
|
|
Type underlyingType = Enum.GetUnderlyingType(type);
|
|
if ((underlyingType == typeof(Int64)) || (underlyingType == typeof(UInt64))) {
|
|
// DevDiv #286382 - Try to provide a better error message by saying exactly what property failed.
|
|
string errorMessage = (currentMember != null)
|
|
? String.Format(CultureInfo.CurrentCulture, AtlasWeb.JSON_CannotSerializeMemberGeneric, currentMember.Name, currentMember.ReflectedType.FullName) + " " + AtlasWeb.JSON_InvalidEnumType
|
|
: AtlasWeb.JSON_InvalidEnumType;
|
|
throw new InvalidOperationException(errorMessage);
|
|
}
|
|
// DevDiv Bugs 154763: call ToString("D") rather than cast to int
|
|
// to support enums that are based on other integral types
|
|
sb.Append(((Enum)o).ToString("D"));
|
|
return;
|
|
}
|
|
|
|
try {
|
|
// The following logic performs circular reference detection
|
|
if (objectsInUse == null) {
|
|
// Create the table on demand
|
|
objectsInUse = new Hashtable(new ReferenceComparer());
|
|
}
|
|
else if (objectsInUse.ContainsKey(o)) {
|
|
// If the object is already there, we have a circular reference!
|
|
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.JSON_CircularReference, type.FullName));
|
|
}
|
|
// Add the object to the objectsInUse
|
|
objectsInUse.Add(o, null);
|
|
|
|
// Dictionaries are represented as Javascript objects. e.g. { name1: val1, name2: val2 }
|
|
IDictionary od = o as IDictionary;
|
|
if (od != null) {
|
|
SerializeDictionary(od, sb, depth, objectsInUse, serializationFormat);
|
|
return;
|
|
}
|
|
|
|
// Enumerations are represented as Javascript arrays. e.g. [ val1, val2 ]
|
|
IEnumerable oenum = o as IEnumerable;
|
|
if (oenum != null) {
|
|
SerializeEnumerable(oenum, sb, depth, objectsInUse, serializationFormat);
|
|
return;
|
|
}
|
|
|
|
// Serialize all public fields and properties.
|
|
SerializeCustomObject(o, sb, depth, objectsInUse, serializationFormat);
|
|
}
|
|
finally {
|
|
// Remove the object from the circular reference detection table
|
|
if (objectsInUse != null) {
|
|
objectsInUse.Remove(o);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal enum SerializationFormat {
|
|
JSON,
|
|
JavaScript
|
|
}
|
|
}
|
|
}
|