using System;

using System.Collections;

#if !NET_35

using System.Collections.Concurrent;

#endif

using System.Collections.Generic;

#if !NET_35

using System.Dynamic;

#endif

using System.Globalization;

using System.IO;

using System.Linq;

using System.Reflection;

using System.Reflection.Emit;

using System.Runtime.CompilerServices;

using System.Security;

#if !(NET_PCL || NET_STANDARD)

using System.Security.Permissions;

#endif

using System.Text;

using System.Xml.Serialization;

#if NET_STANDARD && !NET_STANDARD_20 && !NET5_0 && !NET6_0_OR_GREATER

using Microsoft.Extensions.DependencyModel;

#endif

using NetJSON.Internals;

namespace NetJSON {

public unsafe static partial class NetJSON {

sealed class DynamicNetJSONSerializer<T> : NetJSONSerializer<T>

{

readonly Func<TextReader, T> _DeserializeTextReader;

readonly Func<string, T> _Deserialize;

readonly Func<TextReader, NetJSONSettings, T> _DeserializeTextReaderWithSettings;

readonly Func<string, NetJSONSettings, T> _DeserializeWithSettings;

readonly Func<T, string> _Serialize;

readonly Func<T, NetJSONSettings, string> _SerializeWithSettings;

readonly Action<T, TextWriter> _SerializeTextWriter;

readonly Action<T, TextWriter, NetJSONSettings> _SerializeTextWriterWithSettings;

private Type _objType;

public Type ObjType

{

get

{

return _objType ?? (_objType = typeof(T));

}

}

public bool IsPrimitive

{

get

{

return ObjType.IsPrimitiveType();

}

}

private Module ManifestModule

{

get

{

return

#if NET_STANDARD

ObjType.GetTypeInfo().Assembly.ManifestModule

#else

Assembly.GetExecutingAssembly().ManifestModule

#endif

;

}

}

public DynamicNetJSONSerializer() {

_DeserializeTextReader = CreateDeserializerWithTextReader();

_Deserialize = CreateDeserializer();

_DeserializeTextReaderWithSettings = CreateDeserializerWithTextReaderSettings();

_DeserializeWithSettings = CreateDeserializerWithSettings();

_Serialize = CreateSerializer();

_SerializeTextWriter = CreateSerializerWithTextWriter();

_SerializeTextWriterWithSettings = CreateSerializerWithTextWriterSettings();

_SerializeWithSettings = CreateSerializerWithSettings();

}

Func<TextReader, T> CreateDeserializerWithTextReader() {

var meth = new DynamicMethod("DeserializeValueTextReader", ObjType, new[] { _textReaderType }, ManifestModule, true);

var rdil = meth.GetILGenerator();

var readMethod = WriteDeserializeMethodFor(null, ObjType);

rdil.Emit(OpCodes.Ldarg_0);

rdil.Emit(OpCodes.Callvirt, _textReaderReadToEnd);

rdil.Emit(OpCodes.Call, _settingsCurrentSettings);

rdil.Emit(OpCodes.Call, readMethod);

rdil.Emit(OpCodes.Ret);

return meth.CreateDelegate(typeof(Func<TextReader, T>)) as Func<TextReader, T>;

}

Func<string, T> CreateDeserializer() {

var meth = new DynamicMethod("DeserializeValue", ObjType, new[] { _stringType }, ManifestModule, true);

var dil = meth.GetILGenerator();

var readMethod = WriteDeserializeMethodFor(null, ObjType);

dil.Emit(OpCodes.Ldarg_0);

dil.Emit(OpCodes.Call, _settingsCurrentSettings);

dil.Emit(OpCodes.Call, readMethod);

dil.Emit(OpCodes.Ret);

return meth.CreateDelegate(typeof(Func<string, T>)) as Func<string, T>;

}

Func<TextReader, NetJSONSettings, T> CreateDeserializerWithTextReaderSettings() {

var meth = new DynamicMethod("DeserializeValueTextReaderSettings", ObjType, new[] { _textReaderType, _settingsType }, ManifestModule, true);

var rdilWithSettings = meth.GetILGenerator();

var readMethod = WriteDeserializeMethodFor(null, ObjType);

rdilWithSettings.Emit(OpCodes.Ldarg_1);

rdilWithSettings.Emit(OpCodes.Callvirt, _textReaderReadToEnd);

rdilWithSettings.Emit(OpCodes.Ldarg_2);

rdilWithSettings.Emit(OpCodes.Call, readMethod);

rdilWithSettings.Emit(OpCodes.Ret);

return meth.CreateDelegate(typeof(Func<TextReader, NetJSONSettings, T>)) as Func<TextReader, NetJSONSettings, T>;

}

Func<string, NetJSONSettings, T> CreateDeserializerWithSettings() {

var meth = new DynamicMethod("DeserializeValueSettings", ObjType, new[] { _stringType, _settingsType }, ManifestModule, true);

var dilWithSettings = meth.GetILGenerator();

var readMethod = WriteDeserializeMethodFor(null, ObjType);

dilWithSettings.Emit(OpCodes.Ldarg_0);

dilWithSettings.Emit(OpCodes.Ldarg_1);

dilWithSettings.Emit(OpCodes.Call, readMethod);

dilWithSettings.Emit(OpCodes.Ret);

return meth.CreateDelegate(typeof(Func<string, NetJSONSettings, T>)) as Func<string, NetJSONSettings, T>;

}

Func<T, string> CreateSerializer() {

var meth = new DynamicMethod("SerializeValue", _stringType, new[] { ObjType }, ManifestModule, true);

var il = meth.GetILGenerator();

var writeMethod = WriteSerializeMethodFor(null, ObjType, needQuote: !IsPrimitive || ObjType == _stringType);

var sbLocal = il.DeclareLocal(_stringBuilderType);

il.Emit(OpCodes.Call, _generatorGetStringBuilder);

il.EmitClearStringBuilder();

il.Emit(OpCodes.Stloc, sbLocal);

il.Emit(OpCodes.Ldarg_0);

il.Emit(OpCodes.Ldloc, sbLocal);

il.Emit(OpCodes.Call, _settingsCurrentSettings);

il.Emit(OpCodes.Call, writeMethod);

il.Emit(OpCodes.Ldloc, sbLocal);

il.Emit(OpCodes.Callvirt, _stringBuilderToString);

il.Emit(OpCodes.Ret);

return meth.CreateDelegate(typeof(Func<T, string>)) as Func<T, string>;

}

Func<T, NetJSONSettings, string> CreateSerializerWithSettings() {

var meth = new DynamicMethod("SerializeValueSettings", _stringType, new[] { ObjType, _settingsType }, ManifestModule, true);

var ilWithSettings = meth.GetILGenerator();

var writeMethod = WriteSerializeMethodFor(null, ObjType, needQuote: !IsPrimitive || ObjType == _stringType);

var isValueType = ObjType.GetTypeInfo().IsValueType;

var sbLocalWithSettings = ilWithSettings.DeclareLocal(_stringBuilderType);

ilWithSettings.Emit(OpCodes.Call, _generatorGetStringBuilder);

ilWithSettings.EmitClearStringBuilder();

ilWithSettings.Emit(OpCodes.Stloc, sbLocalWithSettings);

ilWithSettings.Emit(OpCodes.Ldarg_0);

ilWithSettings.Emit(OpCodes.Ldloc, sbLocalWithSettings);

ilWithSettings.Emit(OpCodes.Ldarg_1);

ilWithSettings.Emit(OpCodes.Call, writeMethod);

ilWithSettings.Emit(OpCodes.Ldloc, sbLocalWithSettings);

ilWithSettings.Emit(OpCodes.Callvirt, _stringBuilderToString);

ilWithSettings.Emit(OpCodes.Ldarg_1);

ilWithSettings.Emit(OpCodes.Call, _prettifyJSONIfNeeded);

ilWithSettings.Emit(OpCodes.Ret);

return meth.CreateDelegate(typeof(Func<T, NetJSONSettings, string>)) as Func<T, NetJSONSettings, string>;

}

Action<T, TextWriter> CreateSerializerWithTextWriter() {

var meth = new DynamicMethod("SerializeValueTextWriter", _voidType, new[] { typeof(T), _textWriterType }, ManifestModule, true);

var wil = meth.GetILGenerator();

var writeMethod = WriteSerializeMethodFor(null, ObjType, needQuote: !IsPrimitive || ObjType == _stringType);

var wsbLocal = wil.DeclareLocal(_stringBuilderType);

wil.Emit(OpCodes.Call, _generatorGetStringBuilder);

wil.EmitClearStringBuilder();

wil.Emit(OpCodes.Stloc, wsbLocal);

wil.Emit(OpCodes.Ldarg_0);

wil.Emit(OpCodes.Ldloc, wsbLocal);

wil.Emit(OpCodes.Call, _settingsCurrentSettings);

wil.Emit(OpCodes.Call, writeMethod);

wil.Emit(OpCodes.Ldarg_1);

wil.Emit(OpCodes.Ldloc, wsbLocal);

wil.Emit(OpCodes.Callvirt, _stringBuilderToString);

wil.Emit(OpCodes.Callvirt, _textWriterWrite);

wil.Emit(OpCodes.Ret);

return meth.CreateDelegate(typeof(Action<T, TextWriter>)) as Action<T, TextWriter>;

}

Action<T, TextWriter, NetJSONSettings> CreateSerializerWithTextWriterSettings() {

var meth = new DynamicMethod("SerializeValueTextWriterSettings", _voidType, new[] { ObjType, _textWriterType, _settingsType }, ManifestModule, true);

var wilWithSettings = meth.GetILGenerator();

var writeMethod = WriteSerializeMethodFor(null, ObjType, needQuote: !IsPrimitive || ObjType == _stringType);

var wsbLocalWithSettings = wilWithSettings.DeclareLocal(_stringBuilderType);

wilWithSettings.Emit(OpCodes.Call, _generatorGetStringBuilder);

wilWithSettings.EmitClearStringBuilder();

wilWithSettings.Emit(OpCodes.Stloc, wsbLocalWithSettings);

wilWithSettings.Emit(OpCodes.Ldarg_0);

wilWithSettings.Emit(OpCodes.Ldloc, wsbLocalWithSettings);

wilWithSettings.Emit(OpCodes.Ldarg_2);

wilWithSettings.Emit(OpCodes.Call, writeMethod);

wilWithSettings.Emit(OpCodes.Ldarg_1);

wilWithSettings.Emit(OpCodes.Ldloc, wsbLocalWithSettings);

wilWithSettings.Emit(OpCodes.Callvirt, _stringBuilderToString);

wilWithSettings.Emit(OpCodes.Ldarg_2);

wilWithSettings.Emit(OpCodes.Call, _prettifyJSONIfNeeded);

wilWithSettings.Emit(OpCodes.Callvirt, _textWriterWrite);

wilWithSettings.Emit(OpCodes.Ret);

return meth.CreateDelegate(typeof(Action<T, TextWriter, NetJSONSettings>)) as Action<T, TextWriter, NetJSONSettings>;

}

public override T Deserialize(TextReader reader)

{

return _DeserializeTextReader(reader);

}

public override T Deserialize(string value)

{

return _Deserialize(value);

}

public override T Deserialize(TextReader reader, NetJSONSettings settings)

{

return _DeserializeTextReaderWithSettings(reader, settings);

}

public override T Deserialize(string value, NetJSONSettings settings)

{

return _DeserializeWithSettings(value, settings);

}

public override string Serialize(T value)

{

return _Serialize(value);

}

public override string Serialize(T value, NetJSONSettings settings)

{

return _SerializeWithSettings(value, settings);

}

public override void Serialize(T value, TextWriter writer)

{

_SerializeTextWriter(value, writer);

}

public override void Serialize(T value, TextWriter writer, NetJSONSettings settings)

{

_SerializeTextWriterWithSettings(value, writer, settings);

}

}

private static class NetJSONCachedSerializer<T> {

public static readonly NetJSONSerializer<T> Serializer = GetSerializer();

private static NetJSONSerializer<T> GetSerializer()

{

#if NET_STANDARD_20 || NET5_0 || NET6_0_OR_GREATER

return new DynamicNetJSONSerializer<T>();

#else

NetJSONSerializer<T> serializer = null;

var type = typeof(T);

if (type.GetTypeInfo().IsGenericType)

{

foreach (var item in type.GetGenericArguments())

{

if (IsPrivate(item))

{

type = item;

break;

}

}

}

if (IsPrivate(type))

serializer = new DynamicNetJSONSerializer<T>();

else serializer = (NetJSONSerializer<T>)Activator.CreateInstance(Generate(typeof(T)));

return serializer;

#endif

}

private static bool IsPrivate(Type type)

{

return type.GetTypeInfo().IsNotPublic ||

type.GetTypeInfo().IsNestedPrivate ||

!type.GetTypeInfo().IsVisible;

}

}

const int BUFFER_SIZE = 11;

const int BUFFER_SIZE_DIFF = BUFFER_SIZE - 2;

const TypeAttributes TypeAttribute =

TypeAttributes.Public | TypeAttributes.Serializable | TypeAttributes.Sealed;

const BindingFlags PropertyBinding = BindingFlags.Instance | BindingFlags.Public;

const BindingFlags MethodBinding = BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance;

const MethodAttributes MethodAttribute =

MethodAttributes.Public

| MethodAttributes.Virtual

| MethodAttributes.Final

| MethodAttributes.HideBySig

| MethodAttributes.NewSlot

| MethodAttributes.SpecialName;

const MethodAttributes StaticMethodAttribute =

MethodAttributes.Public

| MethodAttributes.Static

| MethodAttributes.HideBySig

| MethodAttributes.SpecialName;

internal static readonly Type

_dateTimeType = typeof(DateTime),

_dateTimeOffsetType = typeof(DateTimeOffset),

_enumType = typeof(Enum),

_stringType = typeof(string),

_byteArrayType = typeof(byte[]),

_charType = typeof(char),

_charPtrType = typeof(char*),

_guidType = typeof(Guid),

_boolType = typeof(bool),

_byteType = typeof(byte),

_sbyteType = typeof(sbyte),

_timeSpanType = typeof(TimeSpan),

_stringBuilderType = typeof(StringBuilder),

_listType = typeof(IList),

_dictType = typeof(IDictionary),

_dictStringObject = typeof(Dictionary<string, object>),

_genericDictType = typeof(Dictionary<,>),

_genericListType = typeof(List<>),

_objectType = typeof(object),

_nullableType = typeof(Nullable<>),

_decimalType = typeof(decimal),

_genericCollectionType = typeof(ICollection<>),

_floatType = typeof(float),

_doubleType = typeof(double),

_enumeratorTypeNonGeneric = typeof(IEnumerator),

_idictStringObject = typeof(IDictionary<string, object>),

_ienumerableType = typeof(IEnumerable<>),

_enumeratorType = typeof(IEnumerator<>),

_genericKeyValuePairType = typeof(KeyValuePair<,>),

_invalidJSONExceptionType = typeof(NetJSONInvalidJSONException),

_typeMismatchExceptionType = typeof(NetJSONTypeMismatchException),

_serializerType = typeof(NetJSONSerializer<>),

_expandoObjectType = typeof(ExpandoObject),

_genericDictionaryEnumerator = typeof(Dictionary<,>.Enumerator),

_genericListEnumerator = typeof(List<>.Enumerator),

_typeType = typeof(Type),

_voidType = typeof(void),

_intType = typeof(int),

_shortType = typeof(short),

_longType = typeof(long),

_jsonType = typeof(NetJSON),

_internalJsonType = typeof(SerializerUtilities),

_methodInfoType = typeof(MethodBase),

_fieldInfoType = typeof(FieldInfo),

_textWriterType = typeof(TextWriter),

_tupleContainerType = typeof(TupleContainer),

_netjsonPropertyType = typeof(NetJSONPropertyAttribute),

_textReaderType = typeof(TextReader),

_stringComparison = typeof(StringComparison),

_settingsType = typeof(NetJSONSettings),

_netjsonStringReaderType = typeof(NetJSONStringReader);

static MethodInfo _stringBuilderToString =

_stringBuilderType.GetMethod("ToString", Type.EmptyTypes),

_stringBuilderAppend = _stringBuilderType.GetMethod("Append", new[] { _stringType }),

_stringBuilderAppendObject = _stringBuilderType.GetMethod("Append", new[] { _objectType }),

_stringBuilderAppendChar = _stringBuilderType.GetMethod("Append", new[] { _charType }),

_stringOpEquality = _stringType.GetMethod("op_Equality", MethodBinding),

_tupleContainerAdd = _tupleContainerType.GetMethod("Add"),

_generatorGetStringBuilder = _internalJsonType.GetMethod("GetStringBuilder", MethodBinding),

_generatorIntToStr = _internalJsonType.GetMethod("IntToStr", MethodBinding),

_generatorCharToStr = _internalJsonType.GetMethod("CharToStr", MethodBinding),

_generatorEnumToStr = _internalJsonType.GetMethod("CustomEnumToStr", MethodBinding),

_generatorLongToStr = _internalJsonType.GetMethod("LongToStr", MethodBinding),

_generatorFloatToStr = _internalJsonType.GetMethod("FloatToStr", MethodBinding),

_generatorDoubleToStr = _internalJsonType.GetMethod("DoubleToStr", MethodBinding),

_generatorDecimalToStr = _internalJsonType.GetMethod("DecimalToStr", MethodBinding),

_generatorDateToString = _internalJsonType.GetMethod("AllDateToString", MethodBinding),

_generatorDateOffsetToString = _internalJsonType.GetMethod("AllDateOffsetToString", MethodBinding),

_generatorSByteToStr = _internalJsonType.GetMethod("SByteToStr", MethodBinding),

_guidToStr = _internalJsonType.GetMethod("GuidToStr", MethodBinding),

_byteArrayToStr = _internalJsonType.GetMethod("ByteArrayToStr", MethodBinding),

_objectToString = _objectType.GetMethod("ToString", Type.EmptyTypes),

_stringFormat = _stringType.GetMethod("Format", new[] { _stringType, _objectType }),

_convertBase64 = typeof(Convert).GetMethod("ToBase64String", new[] { _byteArrayType }),

_convertFromBase64 = typeof(Convert).GetMethod("FromBase64String", new[] { _stringType }),

_getStringBasedValue = _internalJsonType.GetMethod("GetStringBasedValue", MethodBinding),

_getNonStringValue = _internalJsonType.GetMethod("GetNonStringValue", MethodBinding),

_isDateValue = _internalJsonType.GetMethod("IsValueDate", MethodBinding),

_toStringIfString = _internalJsonType.GetMethod("ToStringIfString", MethodBinding),

_toStringIfStringObject = _internalJsonType.GetMethod("ToStringIfStringObject", MethodBinding),

_iDisposableDispose = typeof(IDisposable).GetMethod("Dispose"),

_toExpectedType = typeof(AutomaticTypeConverter).GetMethod("ToExpectedType"),

_fastStringToInt = _internalJsonType.GetMethod("FastStringToInt", MethodBinding),

_fastStringToUInt = _internalJsonType.GetMethod("FastStringToUInt", MethodBinding),

_fastStringToUShort = _internalJsonType.GetMethod("FastStringToUShort", MethodBinding),

_fastStringToShort = _internalJsonType.GetMethod("FastStringToShort", MethodBinding),

_fastStringToByte = _internalJsonType.GetMethod("FastStringToByte", MethodBinding),

_fastStringToLong = _internalJsonType.GetMethod("FastStringToLong", MethodBinding),

_fastStringToULong = _internalJsonType.GetMethod("FastStringToULong", MethodBinding),

_fastStringToDecimal = _internalJsonType.GetMethod("FastStringToDecimal", MethodBinding),

_fastStringToFloat = _internalJsonType.GetMethod("FastStringToFloat", MethodBinding),

_fastStringToDate = _internalJsonType.GetMethod("FastStringToDate", MethodBinding),

_fastStringToDateTimeoffset = _internalJsonType.GetMethod("FastStringToDateTimeoffset", MethodBinding),

_fastStringToChar = _internalJsonType.GetMethod("FastStringToChar", MethodBinding),

_fastStringToDouble = _internalJsonType.GetMethod("FastStringToDouble", MethodBinding),

_fastStringToBool = _internalJsonType.GetMethod("FastStringToBool", MethodBinding),

_fastStringToGuid = _internalJsonType.GetMethod("FastStringToGuid", MethodBinding),

_fastStringToType = _internalJsonType.GetMethod("FastStringToType", MethodBinding),

_moveToArrayBlock = _internalJsonType.GetMethod("MoveToArrayBlock", MethodBinding),

_fastStringToByteArray = _internalJsonType.GetMethod("FastStringToByteArray", MethodBinding),

_listToListObject = _internalJsonType.GetMethod("ListToListObject", MethodBinding),

_isListType = _internalJsonType.GetMethod("IsListType", MethodBinding),

_isDictType = _internalJsonType.GetMethod("IsDictionaryType", MethodBinding),

_stringLength = _stringType.GetMethod("get_Length"),

_createString = _internalJsonType.GetMethod("CreateString"),

_isCharTag = _internalJsonType.GetMethod("IsCharTag"),

_isEndChar = _internalJsonType.GetMethod("IsEndChar", MethodBinding),

_isArrayEndChar = _internalJsonType.GetMethod("IsArrayEndChar", MethodBinding),

_encodedJSONString = _jsonType.GetMethod("EncodedJSONString", MethodBinding),

_decodeJSONString = _jsonType.GetMethod("DecodeJSONString", MethodBinding),

_readerDeserializer = _jsonType.GetMethod("ReaderDeserializer", MethodBinding),

_skipProperty = _internalJsonType.GetMethod("SkipProperty", MethodBinding),

_prettifyJSONIfNeeded = _jsonType.GetMethod("PrettifyJSONIfNeeded", MethodBinding),

_isRawPrimitive = _internalJsonType.GetMethod("IsRawPrimitive", MethodBinding),

_isInRange = _internalJsonType.GetMethod("IsInRange", MethodBinding),

_dateTimeParse = _dateTimeType.GetMethod("Parse", new[] { _stringType }),

_timeSpanParse = _timeSpanType.GetMethod("Parse", new[] { _stringType }),

_getChars = _stringType.GetMethod("get_Chars"),

_dictSetItem = _dictType.GetMethod("set_Item"),

_textWriterWrite = _textWriterType.GetMethod("Write", new[] { _stringType }),

_textReaderReadToEnd = _textReaderType.GetMethod("ReadToEnd"),

_typeopEquality = _typeType.GetMethod("op_Equality", MethodBinding),

_cTypeOpEquality = _internalJsonType.GetMethod("CustomTypeEquality", MethodBinding),

_assemblyQualifiedName = _typeType.GetProperty("AssemblyQualifiedName").GetGetMethod(),

_objectGetType = _objectType.GetMethod("GetType", MethodBinding),

_needQuote = _internalJsonType.GetMethod("NeedQuotes", MethodBinding),

_typeGetTypeFromHandle = _typeType.GetMethod("GetTypeFromHandle", MethodBinding),

_methodGetMethodFromHandle = _methodInfoType.GetMethod("GetMethodFromHandle", new Type[] { typeof(RuntimeMethodHandle) }),

_methodGetFieldFromHandle = _fieldInfoType.GetMethod("GetFieldFromHandle", new Type[] { typeof(RuntimeFieldHandle) }),

_objectEquals = _objectType.GetMethod("Equals", new[] { _objectType }),

_stringEqualCompare = _stringType.GetMethod("Equals", new[] { _stringType, _stringType, typeof(StringComparison) }),

_stringConcat = _stringType.GetMethod("Concat", new[] { _objectType, _objectType, _objectType, _objectType }),

_IsCurrentAQuotMethod = _internalJsonType.GetMethod("IsCurrentAQuot", MethodBinding),

_getTypeIdentifierInstanceMethod = _internalJsonType.GetMethod("GetTypeIdentifierInstance", MethodBinding),

_settingsUseEnumStringProp = _settingsType.GetProperty("UseEnumString", MethodBinding).GetGetMethod(),

_settingsUseStringOptimization = _settingsType.GetProperty("UseStringOptimization", MethodBinding).GetGetMethod(),

_settingsHasOverrideQuoteChar = _settingsType.GetProperty("HasOverrideQuoteChar", MethodBinding).GetGetMethod(),

_settingsDateFormat = _settingsType.GetProperty("DateFormat", MethodBinding).GetGetMethod(),

_settingsSkipDefaultValue = _settingsType.GetProperty("SkipDefaultValue", MethodBinding).GetGetMethod(),

_getUninitializedInstance = _internalJsonType.GetMethod("GetUninitializedInstance", MethodBinding),

_flagEnumToString = _internalJsonType.GetMethod("FlagEnumToString", MethodBinding),

_flagStringToEnum = _internalJsonType.GetMethod("FlagStringToEnum", MethodBinding),

_setterPropertyValueMethod = _internalJsonType.GetMethod("SetterPropertyValue", MethodBinding),

_setterFieldValueMethod = _internalJsonType.GetMethod("SetterFieldValue", MethodBinding),

_settingsCurrentSettings = _settingsType.GetProperty("CurrentSettings", MethodBinding).GetGetMethod(),

_settingsCamelCase = _settingsType.GetProperty("CamelCase", MethodBinding).GetGetMethod(),

_throwIfInvalidJSON = _internalJsonType.GetMethod("ThrowIfInvalidJSON", MethodBinding),

_failIfInvalidCharacter = _internalJsonType.GetMethod("FailIfInvalidCharacter", MethodBinding),

_toCamelCase = _internalJsonType.GetMethod("ToCamelCase", MethodBinding);

private static FieldInfo _guidEmptyGuid = _guidType.GetField("Empty"),

_settingQuoteChar = _settingsType.GetField("_quoteChar", MethodBinding),

_settingsCaseComparison = _settingsType.GetField("_caseComparison", MethodBinding),

_settingQuoteCharString = _settingsType.GetField("_quoteCharString", MethodBinding);

const int Delimeter = (int)',', ColonChr = (int)':',

ArrayOpen = (int)'[', ArrayClose = (int)']', ObjectOpen = (int)'{', ObjectClose = (int)'}';

const string IsoFormat = "{0:yyyy-MM-ddTHH:mm:ss.fffZ}",

TypeIdentifier = "$type",

ClassStr = "Class", _dllStr = ".dll",

NullStr = "null",

IListStr = "IList`1",

IDictStr = "IDictionary`2",

IReadOnlyDictionaryStr = "IReadOnlyDictionary`2",

KeyValueStr = "KeyValuePair`2",

ICollectionStr = "ICollection`1",

IEnumerableStr = "IEnumerable`1",

IReadOnlyCollectionStr = "IReadOnlyCollection`1",

IReadOnlyListStr = "IReadOnlyList`1",

CreateListStr = "CreateList",

CreateClassOrDictStr = "CreateClassOrDict",

Dynamic = "Dynamic",

ExtractStr = "Extract",

SetStr = "Set",

WriteStr = "Write", ReadStr = "Read", ReadEnumStr = "ReadEnum",

CarrotQuoteChar = "`",

ArrayStr = "Array", AnonymousBracketStr = "<>",

ArrayLiteral = "[]",

Colon = ":",

ToTupleStr = "ToTuple",

SerializeStr = "Serialize", DeserializeStr = "Deserialize", SettingsFieldName = "_settingsField";

static ConstructorInfo _strCtorWithPtr = _stringType.GetConstructor(new[] { typeof(char*), _intType, _intType });

static ConstructorInfo _invalidJSONCtor = _invalidJSONExceptionType.GetConstructor(Type.EmptyTypes);

static ConstructorInfo _typeMismatchExceptionCtor = _typeMismatchExceptionType.GetConstructor(Type.EmptyTypes);

static ConstructorInfo _settingsCtor = _settingsType.GetConstructor(Type.EmptyTypes);

private static ConcurrentDictionary<string, object> _dictLockObjects = new ConcurrentDictionary<string, object>();

static ConcurrentDictionary<Type, MethodInfo> _registeredSerializerMethods =

new ConcurrentDictionary<Type, MethodInfo>();

static ConcurrentDictionary<string, MethodInfo> _registeredCustomSerializerMethods =

new ConcurrentDictionary<string, MethodInfo>();

static ConcurrentDictionary<string, MethodInfo> _registeredCustomDeserializerMethods =

new ConcurrentDictionary<string, MethodInfo>();

static Dictionary<Type, MethodInfo> _defaultSerializerTypes =

new Dictionary<Type, MethodInfo> {

{_enumType, null},

{_stringType, null},

{_charType, _generatorCharToStr},

{_intType, _generatorIntToStr},

{_shortType, _generatorIntToStr},

{_longType, _generatorLongToStr},

{_decimalType, _generatorDecimalToStr},

{_boolType, null},

{_doubleType, _generatorDoubleToStr},

{_floatType, _generatorFloatToStr},

{_byteArrayType, _byteArrayToStr},

{_guidType, _guidToStr},

{_objectType, null}

};

static ConcurrentDictionary<Type, Type> _types =

new ConcurrentDictionary<Type, Type>();

static ConcurrentDictionary<string, MethodInfo> _writeMethodBuilders =

new ConcurrentDictionary<string, MethodInfo>();

static ConcurrentDictionary<string, MethodInfo> _setValueMethodBuilders =

new ConcurrentDictionary<string, MethodInfo>();

static ConcurrentDictionary<string, MethodInfo> _readMethodBuilders =

new ConcurrentDictionary<string, MethodInfo>();

static ConcurrentDictionary<string, MethodInfo> _createListMethodBuilders =

new ConcurrentDictionary<string, MethodInfo>();

static ConcurrentDictionary<string, MethodInfo> _extractMethodBuilders =

new ConcurrentDictionary<string, MethodInfo>();

static ConcurrentDictionary<string, MethodInfo> _readDeserializeMethodBuilders =

new ConcurrentDictionary<string, MethodInfo>();

static ConcurrentDictionary<string, MethodInfo> _writeEnumToStringMethodBuilders =

new ConcurrentDictionary<string, MethodInfo>();

static ConcurrentDictionary<string, MethodInfo> _readEnumToStringMethodBuilders =

new ConcurrentDictionary<string, MethodInfo>();

static readonly ConcurrentDictionary<MethodInfo, Delegate> _setMemberValues = new ConcurrentDictionary<MethodInfo, Delegate>();

static readonly ConcurrentDictionary<FieldInfo, Delegate> _setMemberFieldValues = new ConcurrentDictionary<FieldInfo, Delegate>();

static ConcurrentDictionary<string, Func<object>> _typeIdentifierFuncs = new ConcurrentDictionary<string, Func<object>>();

static ConcurrentDictionary<string, Func<NetJSONStringReader, NetJSONSettings, object>> _customDeserializerForNetJSONStringReaders =

new ConcurrentDictionary<string, Func<NetJSONStringReader, NetJSONSettings, object>>();

static ConcurrentDictionary<Type, bool> _primitiveTypes =

new ConcurrentDictionary<Type, bool>();

static ConcurrentDictionary<Type, Type> _nullableTypes =

new ConcurrentDictionary<Type, Type>();

static ConcurrentDictionary<Type, List<Type>> _includedTypeTypes = new ConcurrentDictionary<Type, List<Type>>();

static ConcurrentDictionary<Type, object> _serializers = new ConcurrentDictionary<Type, object>();

static ConcurrentDictionary<Type, NetJSONMemberInfo[]> _typeProperties =

new ConcurrentDictionary<Type, NetJSONMemberInfo[]>();

static ConcurrentDictionary<string, string> _fixes =

new ConcurrentDictionary<string, string>();

private static object _lockObject = new object();

private static unsafe void memcpy(char* dmem, char* smem, int charCount) {

if ((((int)dmem) & 2) != 0) {

dmem[0] = smem[0];

dmem++;

smem++;

charCount--;

}

while (charCount >= 8) {

*((int*)dmem) = *((int*)smem);

*((int*)(dmem + 2)) = *((int*)(smem + 2));

*((int*)(dmem + 4)) = *((int*)(smem + 4));

*((int*)(dmem + 6)) = *((int*)(smem + 6));

dmem += 8;

smem += 8;

charCount -= 8;

}

if ((charCount & 4) != 0) {

*((int*)dmem) = *((int*)smem);

*((int*)(dmem + 2)) = *((int*)(smem + 2));

dmem += 4;

smem += 4;

}

if ((charCount & 2) != 0) {

*((int*)dmem) = *((int*)smem);

dmem += 2;

smem += 2;

}

if ((charCount & 1) != 0) {

dmem[0] = smem[0];

}

}

static bool IsPrimitiveType(this Type type) {

return _primitiveTypes.GetOrAdd(type, key => {

lock (GetDictLockObject("IsPrimitiveType")) {

if (key.GetTypeInfo().IsGenericType &&

key.GetGenericTypeDefinition() == _nullableType)

key = key.GetGenericArguments()[0];

return key == _stringType ||

key.GetTypeInfo().IsPrimitive || key == _dateTimeType ||

key == _dateTimeOffsetType ||

key == _decimalType || key == _timeSpanType ||

key == _guidType || key == _charType ||

key == _typeType ||

key.GetTypeInfo().IsEnum || key == _byteArrayType;

}

});

}

private static Type GetNullableType(this Type type) {

return _nullableTypes.GetOrAdd(type, key => {

lock (GetDictLockObject("GetNullableType"))

return key.Name.StartsWith("Nullable`") ? key.GetGenericArguments()[0] : null;

});

}

private static void LookupAttribute<T>(ref NetJSONPropertyAttribute attr, MemberInfo memberInfo, Func<T, string> func) where T : Attribute

{

if (attr != null)

return;

var memberAttr = memberInfo.GetCustomAttributes(typeof(T), true).OfType<T>().FirstOrDefault();

if (memberAttr == null)

return;

attr = new NetJSONPropertyAttribute(func(memberAttr));

}

private static NetJSONPropertyAttribute GetSerializeAs(MemberInfo memberInfo)

{

NetJSONPropertyAttribute attr = null;

if (SerializeAs != null)

{

var name = SerializeAs(memberInfo);

if (!string.IsNullOrEmpty(name))

{

attr = new NetJSONPropertyAttribute(name);

}

}

#if !NET_STANDARD

LookupAttribute<XmlAttributeAttribute>(ref attr, memberInfo, it => it.AttributeName);

LookupAttribute<XmlElementAttribute>(ref attr, memberInfo, it => it.ElementName);

LookupAttribute<XmlArrayAttribute>(ref attr, memberInfo, it => it.ElementName);

#endif

return attr;

}

private static bool GetCanSerialize(MemberInfo memberInfo)

{

if(CanSerialize != null)

{

return CanSerialize(memberInfo);

}

return true;

}

internal static NetJSONMemberInfo[] GetTypeProperties(this Type type) {

return _typeProperties.GetOrAdd(type, key => {

lock (GetDictLockObject("GetTypeProperties")) {

var props = key.GetProperties(PropertyBinding)

.Where(x => x.GetIndexParameters().Length == 0 && GetCanSerialize(x))

.Select(x =>

{

var attr = x.GetCustomAttributes(_netjsonPropertyType, true).OfType<NetJSONPropertyAttribute>().FirstOrDefault();

if (attr == null)

{

attr = GetSerializeAs(x);

}

return new NetJSONMemberInfo

{

Member = x,

Attribute = attr

};

});

if (_includeFields) {

props = props.Union(key.GetFields(PropertyBinding).Where(x => GetCanSerialize(x)).Select(x => new NetJSONMemberInfo { Member = x, Attribute = x.GetCustomAttributes(_netjsonPropertyType, true).OfType<NetJSONPropertyAttribute>().FirstOrDefault() ?? GetSerializeAs(x) }));

}

var result = props.ToArray();

#if NET_35

if (result.Where(x => x.Attribute != null).Any(x => x.Attribute.Name.IsNullOrWhiteSpace() || x.Attribute.Name.Contains(" ")))

throw new NetJSONInvalidJSONPropertyException();

#else

if (result.Where(x => x.Attribute != null).Any(x => string.IsNullOrWhiteSpace(x.Attribute.Name) || x.Attribute.Name.Contains(" ")))

throw new NetJSONInvalidJSONPropertyException();

#endif

return result;

}

});

}

private static void LoadQuotChar(ILGenerator il) {

il.Emit(OpCodes.Ldarg_2);

il.Emit(OpCodes.Ldfld, _settingQuoteCharString);

//il.Emit(OpCodes.Ldsfld, _threadQuoteStringField);

}

private static bool _useTickFormat = true;

[Obsolete("Use NetJSON.DateFormat = NetJSONDateFormat.ISO instead. UseISOFormat will be removed in the future")]

public static bool UseISOFormat {

set {

_useTickFormat = !value;

if (!_useTickFormat)

_dateFormat = NetJSONDateFormat.ISO;

}

}

private static NetJSONDateFormat _dateFormat = NetJSONDateFormat.Default;

private static NetJSONTimeZoneFormat _timeZoneFormat = NetJSONTimeZoneFormat.Unspecified;

private static bool _useSharedAssembly = true;

/// <summary>

/// Flag to determine whether to store all generate serializer for types in a single assembly

/// </summary>

public static bool ShareAssembly {

set {

_useSharedAssembly = value;

}

}

/// <summary>

/// Delegate to override what member can get serialized

/// </summary>

public static Func<MemberInfo, bool> CanSerialize { private get; set; }

/// <summary>

/// Delegate to override what name to use for members when serialized

/// </summary>

public static Func<MemberInfo, string> SerializeAs { private get; set; }

[Obsolete("Use NetJSONSettings.DateFormat")]

public static NetJSONDateFormat DateFormat {

set {

_dateFormat = value;

}

internal get {

return _dateFormat;

}

}

[Obsolete("Use NetJSONSettings.TimeZoneFormat")]

public static NetJSONTimeZoneFormat TimeZoneFormat {

set {

_timeZoneFormat = value;

}

internal get {

return _timeZoneFormat;

}

}

private static NetJSONQuote _quoteType = NetJSONQuote.Default;

[Obsolete("Use NetJSONSettings.QuoteType")]

public static NetJSONQuote QuoteType {

set {

_quoteType = value;

//_ThreadQuoteString = (_ThreadQuoteChar = value == NetJSONQuote.Single ? QuotSingleChar : QuotDoubleChar).ToString();

}

internal get {

return _quoteType;

}

}

private static bool _caseSensitive = true;

[Obsolete("Use NetJSONSettings.CaseSensitive")]

public static bool CaseSensitive {

set {

_caseSensitive = value;

}

internal get {

return _caseSensitive;

}

}

private static bool _useEnumString = false;

public static bool UseEnumString {

set {

_useEnumString = value;

}

internal get {

return _useEnumString;

}

}

private static bool _includeFields = true;

[Obsolete("All fields will be included by default. This property will be removed in future release")]

public static bool IncludeFields {

set {

_includeFields = true;

}

internal get {

return _includeFields;

}

}

private static bool _skipDefaultValue = true;

[Obsolete("Use NetJSONSettings.SkipDefaultValue")]

public static bool SkipDefaultValue {

set {

_skipDefaultValue = value;

}

internal get {

return _skipDefaultValue;

}

}

private static bool _useStringOptimization = true;

[Obsolete("Use NetJSONSettings.UseStringOptimization")]

public static bool UseStringOptimization {

set {

_useStringOptimization = value;

}

internal get {

return _useStringOptimization;

}

}

private static bool _generateAssembly = false;

[Obsolete("Use NetJSONSettings.GenerateAssembly")]

public static bool GenerateAssembly {

set {

_generateAssembly = value;

}

}

private static bool _includeTypeInformation = false;

public static bool IncludeTypeInformation {

set {

_includeTypeInformation = value;

}

internal get {

return _includeTypeInformation;

}

}

internal static object GetTypeIdentifierInstance(string typeName) {

return _typeIdentifierFuncs.GetOrAdd(typeName, _ => {

lock (GetDictLockObject("GetTypeIdentifier")) {

var type = Type.GetType(typeName, throwOnError: false);

if (type == null)

throw new InvalidOperationException(string.Format("Unable to resolve {0} with value = {1}", TypeIdentifier, typeName));

var ctor = type.GetConstructor(Type.EmptyTypes);

var meth = new DynamicMethod(Guid.NewGuid().ToString("N"), _objectType, null, restrictedSkipVisibility: true);

var il = meth.GetILGenerator();

if (ctor == null)

il.Emit(OpCodes.Call, _getUninitializedInstance.MakeGenericMethod(type));

else

il.Emit(OpCodes.Newobj, ctor);//NewObjNoctor

il.Emit(OpCodes.Ret);

return meth.CreateDelegate(typeof(Func<object>)) as Func<object>;

}

})();

}

internal static bool NeedQuotes(Type type, NetJSONSettings settings) {

return type == _stringType || type == _charType || type == _guidType || type == _timeSpanType || ((type == _dateTimeType || type == _dateTimeOffsetType) && settings.DateFormat != NetJSONDateFormat.EpochTime) || type == _byteArrayType || (settings.UseEnumString && type.GetTypeInfo().IsEnum);

}

private static MethodInfo GenerateFastObjectToString(TypeBuilder type) {

return _readMethodBuilders.GetOrAdd("FastObjectToString", _ => {

lock (GetDictLockObject("GenerateFastObjectToString")) {

var method = type.DefineMethodEx("FastObjectToString", StaticMethodAttribute, _voidType,

new[] { _objectType, _stringBuilderType, _settingsType });

var il = method.GetILGenerator();

var typeLocal = il.DeclareLocal(_typeType);

var needQuoteLocal = il.DeclareLocal(_boolType);

var needQuoteStartLabel = il.DefineLabel();

var needQuoteEndLabel = il.DefineLabel();

il.Emit(OpCodes.Ldarg_0);

il.Emit(OpCodes.Callvirt, _objectGetType);

il.Emit(OpCodes.Stloc, typeLocal);

var isListTypeLabel = il.DefineLabel();

il.Emit(OpCodes.Ldloc, typeLocal);

il.Emit(OpCodes.Call, _isListType);

il.Emit(OpCodes.Brfalse, isListTypeLabel);

il.Emit(OpCodes.Ldarg_0);

il.Emit(OpCodes.Castclass, _listType);

il.Emit(OpCodes.Call, _listToListObject);

il.Emit(OpCodes.Starg, 0);

WriteCollection(type, typeof(List<object>), il);

il.Emit(OpCodes.Ret);

il.MarkLabel(isListTypeLabel);

var isDictTypeLabel = il.DefineLabel();

il.Emit(OpCodes.Ldloc, typeLocal);

il.Emit(OpCodes.Call, _isDictType);

il.Emit(OpCodes.Brfalse, isDictTypeLabel);

il.Emit(OpCodes.Ldarg_0);

il.Emit(OpCodes.Castclass, _dictStringObject);

il.Emit(OpCodes.Starg, 0);

WriteCollection(type, _dictStringObject, il);

il.Emit(OpCodes.Ret);